@bezda/rhp-mcp 0.1.1 → 0.1.2

package/src/check/browser.js

@@ -77,12 +77,18 @@ export async function launch() {
 
   const failures = [];
 
+  // Chromium's own sandbox on (Playwright leaves it off): the page runs code the checker did not write. Where it
+  // cannot start (some Linux containers, or running as root), the same browser runs without it. WebRTC sends nothing
+  // outside a proxy, so it cannot reach the network around the check's router.
+  const args = ["--hide-scrollbars", "--disable-lcd-text", "--force-webrtc-ip-handling-policy=disable_non_proxied_udp"];
   for (const t of tries) {
-    try {
-      const browser = await chromium.launch({ headless: true, ...t.options, args: ["--hide-scrollbars", "--disable-lcd-text"] });
-      return { browser, name: `${t.name} ${browser.version()}` };
-    } catch (e) {
-      failures.push(`${t.name}: ${String(e.message ?? e).split("\n")[0]}`);
+    for (const chromiumSandbox of [true, false]) {
+      try {
+        const browser = await chromium.launch({ headless: true, chromiumSandbox, ...t.options, args });
+        return { browser, name: `${t.name} ${browser.version()}`, sandboxed: chromiumSandbox };
+      } catch (e) {
+        if (!chromiumSandbox) failures.push(`${t.name}: ${String(e.message ?? e).split("\n")[0]}`);
+      }
     }
   }
 

package/src/check/findings.js

@@ -198,6 +198,20 @@ export function fromProbe(f, context) {
         message: `Tab reaches ${f.what}${f.more ? ` and ${f.more} more` : ""}, but nothing on screen shows the focus there: a keyboard reader cannot see where it is.`,
         fix: "Show focus: take off outline: none, or put a :focus-visible style that shows in its place (outline: 2px solid in the ink color, outline-offset: 2px; on a slat, in the slat type's css).",
       };
+    case "selection-hover-stays":
+      return {
+        level: "warning",
+        code: f.code,
+        message: `After clicking ${f.selected}, hovering ${f.target} overrides that selection, but moving beside the chart (${f.what}) does not give the selected item back. Leaving the poster does.`,
+        fix: "This chart already has click selection with a temporary hover override. Unless the user explicitly requested a different behavior, end only the hover preview when the pointer leaves the chart area, including when it moves onto the poster's readout, text or margin, and show the existing click selection again. Keep hover and selection separate; do not clear the selection on pointerleave, add a new interaction, or change a different interaction style.",
+      };
+    case "selection-reset":
+      return {
+        level: "warning",
+        code: f.code,
+        message: `This chart has click selection with a temporary hover override. After selecting ${f.target}, clicking beside the chart (${f.what}), inside the poster, does not restore its initial state.`,
+        fix: "Unless the user explicitly requested persistent selection or another reset behavior, make a click or tap inside this poster but outside its chart area reset this existing selection and its hover preview. Restore the meaningful default selection the chart already had (such as the analysis subject); if it had none, clear all selections. Preserve that default rather than inventing one, and leave controls, links, other charts, and keyboard interactions alone. Do not add click selection or hover to a chart that lacks them. Apply the fix in the chart source and rerun the checker; the checker does not rewrite the file.",
+      };
     default:
       return { level: "error", code: f.code, message: JSON.stringify(f), fix: "" };
   }

package/src/check/index.js

@@ -35,7 +35,7 @@ import fs from "fs";
 import os from "os";
 import path from "path";
 import crypto from "crypto";
-import { pathToFileURL } from "url";
+import { pathToFileURL, fileURLToPath } from "url";
 import { detectFormat, bundle, guardedStandalone, htmlProblems, packages, contentType } from "./build.js";
 import { launch, NO_BROWSER_FIX } from "./browser.js";
 import { install } from "./inpage.js";
@@ -43,9 +43,11 @@ import { fromProbe, fixForError, placeOf } from "./findings.js";
 import { textContrast, faintMarks, colorBlind } from "./colors.js";
 import { decode } from "./png.js";
 import { interact as interactionPass } from "./interact.js";
+import { selectionBehavior } from "./selection.js";
 import { readMap, lookup } from "./sourcemap.js";
 import { sourceProblems } from "./source.js";
 import { report } from "./report.js";
+import { fetchPublic, READ_METHODS, denyBrowserNetwork } from "./network.js";
 
 const ORIGIN = "http://rhp-check.localhost";
 const CDN = /^https?:\/\/(?:cdn\.jsdelivr\.net\/npm|unpkg\.com|esm\.sh)\/@bezda\/rhp(?:@([^/]+))?\/(?:dist\/)?([^?#]*)/;
@@ -184,18 +186,45 @@ export async function check(options = {}) {
   fs.mkdirSync(outDir, { recursive: true });
   const name = path.basename(file).replace(/\.[^.]+$/, "");
 
+  // Both the spelled path and the resolved path must remain below this root.
+  // This also rejects hidden paths and symlinks that lead outside the chart folder.
+  const scopedFile = (root, candidate) => {
+    try {
+      const inside = (base, name) => {
+        const rel = path.relative(base, name);
+        return rel && !rel.startsWith(".." + path.sep) && rel !== ".." && !path.isAbsolute(rel) && !rel.split(path.sep).some((part) => part.startsWith("."));
+      };
+      if (!inside(path.resolve(root), path.resolve(candidate))) return null;
+      const real = fs.realpathSync(candidate);
+      return inside(fs.realpathSync(root), real) && fs.statSync(real).isFile() ? real : null;
+    } catch {
+      return null;
+    }
+  };
+
   // Answers every request the page makes: the bundle and the user's files for a bundled chart, rhp from the CDN, and
   // the rest of the web (fonts) through a short timeout, kept for the next width
   const route = async (r) => {
     const url = r.request().url();
 
+    if (url.startsWith("file:")) {
+      let local = null;
+      try {
+        const requested = fileURLToPath(url);
+        local = path.resolve(requested) === path.resolve(file) ? file : scopedFile(path.dirname(file), requested);
+      } catch {
+        // A malformed file URL is not a local asset.
+      }
+      return local ? r.fulfill({ body: fs.readFileSync(local), contentType: contentType(local) }) : r.abort("blockedbyclient");
+    }
+
     if (url.startsWith(ORIGIN + "/")) {
       const p = decodeURIComponent(new URL(url).pathname);
-      if (p === "/") return r.fulfill({ body: built.html, contentType: "text/html" });
-      if (built.files.has(p)) return r.fulfill({ body: built.files.get(p).body, contentType: built.files.get(p).type });
+      if (p === "/" && built) return r.fulfill({ body: built.html, contentType: "text/html" });
+      if (built?.files.has(p)) return r.fulfill({ body: built.files.get(p).body, contentType: built.files.get(p).type });
       if (p === "/favicon.ico") return r.fulfill({ status: 204, body: "" });
-      const local = path.join(path.dirname(file), p);
-      if (local.startsWith(path.dirname(file)) && fs.existsSync(local) && fs.statSync(local).isFile()) return r.fulfill({ body: fs.readFileSync(local), contentType: contentType(local) });
+      const local = scopedFile(path.dirname(file), path.join(path.dirname(file), p));
+      if (local) return r.fulfill({ body: fs.readFileSync(local), contentType: contentType(local) });
       return r.fulfill({ status: 404, body: "not found: " + p });
     }
 
@@ -207,32 +236,37 @@ export async function check(options = {}) {
       const sub = rest === "standalone" || rest === "standalone.js" || rest === "" ? "standalone.js" : rest;
       const headers = { "access-control-allow-origin": "*" };
       if (sub === "standalone.js") return r.fulfill({ body: standalone ?? fs.readFileSync(path.join(pkgs.rhp.root, "dist/standalone.js")), contentType: "text/javascript", headers });
-      const f = path.join(pkgs.rhp.root, "dist", sub.replace(/^dist\//, ""));
-      if (fs.existsSync(f)) return r.fulfill({ body: fs.readFileSync(f), contentType: contentType(f), headers });
+      const f = scopedFile(path.join(pkgs.rhp.root, "dist"), path.join(pkgs.rhp.root, "dist", sub.replace(/^dist\//, "")));
+      if (f) return r.fulfill({ body: fs.readFileSync(f), contentType: contentType(f), headers });
       return r.fulfill({ status: 404, body: "not in @bezda/rhp: " + sub, headers });
     }
 
     if (!/^https?:/.test(url)) return r.continue();
     if (options.offline) return r.abort("internetdisconnected").catch(() => {});
 
-    if (!remote.has(url)) {
-      remote.set(url, fetched.has(url) ? Promise.resolve(fetched.get(url)) : r.fetch({ timeout: 5000, maxRedirects: 5 }).then(async (res) => {
-        const got = { status: res.status(), headers: res.headers(), body: await res.body() };
-        if (got.status >= 200 && got.status < 300 && fetchedBytes + got.body.length <= KEEP_BYTES) {
+    // The rest of the web, read only and from public addresses only (network.js); a GET answer is kept
+    const method = r.request().method().toUpperCase();
+    if (!READ_METHODS.has(method)) return r.abort("blockedbyclient").catch(() => {});
+    const key = method + " " + url;
+    if (!remote.has(key)) {
+      remote.set(key, method === "GET" && fetched.has(url) ? Promise.resolve(fetched.get(url)) : fetchPublic(url, { method, headers: r.request().headers() }).then((got) => {
+        if (method === "GET" && !got.error && got.status >= 200 && got.status < 300 && fetchedBytes + got.body.length <= KEEP_BYTES) {
           fetched.set(url, got);
           fetchedBytes += got.body.length;
         }
         return got;
-      }, (e) => ({ error: String(e.message ?? e).split("\n")[0] })));
+      }));
     }
-    const got = await remote.get(url);
-    if (got.error) return r.abort("internetdisconnected").catch(() => {});
+    const got = await remote.get(key);
+    if (got.error) return r.abort(got.blocked ? "blockedbyclient" : "internetdisconnected").catch(() => {});
     return r.fulfill({ status: got.status, headers: got.headers, body: got.body }).catch(() => {});
   };
 
   const browser = launched.browser;
   const results = [];
   const screenshots = [];
+  const fenced = new Set();
+  const fence = await denyBrowserNetwork((url) => fenced.add(url));
   const isLocal = (u) => u.startsWith("file:") || u.startsWith(ORIGIN);
 
   // A page with the chart, the probe installed and at rest (in a window of another size when asked); what the page
@@ -258,6 +292,11 @@ export async function check(options = {}) {
     });
     await page.emulateMedia({ reducedMotion });
     await page.route("**/*", route);
+    await context.routeWebSocket(/.*/, (ws) => {
+      // A WebSocket can send arbitrary messages after its handshake, so it is not a read-only fetch.
+      events.push({ kind: "remote-failed", text: ws.url(), error: "net::ERR_BLOCKED_BY_CLIENT" });
+      ws.close({ code: 1008, reason: "WebSockets are blocked by the check" });
+    });
     await page.goto(format === "html" ? pathToFileURL(file).href : ORIGIN + "/", { waitUntil: "load", timeout: 20000 }).catch((e) => events.push({ kind: "pageerror", text: "The page did not finish loading: " + String(e.message).split("\n")[0] }));
     await page.evaluate(install);
     const measured = reducedMotion === "reduce";
@@ -298,7 +337,8 @@ export async function check(options = {}) {
   try {
     await Promise.all(widths.map(async (width, i) => {
       const phone = width <= PHONE;
-      const context = await browser.newContext({ viewport: { width, height: 900 }, deviceScaleFactor: phone ? 2 : 1, hasTouch: phone, colorScheme: dark ? "dark" : "light" });
+      // No service workers (they would answer requests outside the check's router) and no downloads
+      const context = await browser.newContext({ viewport: { width, height: 900 }, deviceScaleFactor: phone ? 2 : 1, hasTouch: phone, colorScheme: dark ? "dark" : "light", serviceWorkers: "block", acceptDownloads: false, proxy: fence.proxy });
       const events = [];
       const w0 = performance.now();
       try {
@@ -361,8 +401,18 @@ export async function check(options = {}) {
       // and taps at a phone's, in the window a phone shows (not when the page never finished loading)
       const interactions = [];
       const unfocused = [];
+      let selection = { findings: [], tested: null };
       const loaded = !events.some((e) => e.kind === "pageerror" && /^The page did not finish loading/.test(e.text));
       if (wantInteract && loaded && (i === 0 || phone)) {
+        if (i === 0) {
+          const audit = await open(context, events, "no-preference");
+          try {
+            selection = await selectionBehavior(audit, { events });
+            guarded.push(...(await audit.evaluate(() => globalThis.__rhpCheck?.findings ?? []).catch(() => [])));
+          } finally {
+            await audit.close();
+          }
+        }
         const fresh = await open(context, events, "no-preference", phone ? { width, height: PHONE_WINDOW } : null);
         const pass = { events, capture: (opts) => capture(fresh, opts, true), shoot: (suffix) => save(fresh, width, suffix, true) };
         const passes = [];
@@ -377,7 +427,7 @@ export async function check(options = {}) {
         guarded.push(...(await fresh.evaluate(() => globalThis.__rhpCheck?.findings ?? []).catch(() => [])));
       }
 
-      results.push({ width, index: i, seen, events, guarded, colorFindings, interactions: interactions.map((x) => ({ width, ...x })), unfocused, swept, ms: Math.round(performance.now() - w0) });
+      results.push({ width, index: i, seen, events, guarded, colorFindings, interactions: interactions.map((x) => ({ width, ...x })), unfocused, selection, swept, ms: Math.round(performance.now() - w0) });
       } catch (error) {
         if (error.code !== "page-unsettled") throw error;
         findings.push({ level: "error", code: error.code, message: error.message, fix: "Let finite entry animations finish, honor prefers-reduced-motion for live updates, or increase the check's settleTimeout for a slow machine.", width });
@@ -386,8 +436,13 @@ export async function check(options = {}) {
       }
     }));
   } finally {
-    if (!options.browser) await browser.close();
+    try {
+      if (!options.browser) await browser.close();
+    } finally {
+      await fence.close();
+    }
   }
+  for (const url of fenced) findings.push({ level: "info", code: "remote-failed", message: `The check blocked an unrouted browser connection to ${url}; no connection was forwarded.`, fix: "Use public HTTP assets or data requests; worker sockets and other direct browser connections are blocked." });
   lap("pages", t);
 
   results.sort((a, b) => a.index - b.index);
@@ -417,7 +472,8 @@ export async function check(options = {}) {
       } else if (e.kind === "request-failed") {
         findings.push({ level: "error", code: "request-failed", message: `${e.text.replace(ORIGIN, "").replace(/^file:\/\//, "")} failed to load (${e.error}).`, fix: "Fix the path, or add the file next to the chart.", width: r.width });
       } else if (e.kind === "remote-failed") {
-        findings.push({ level: "info", code: "remote-failed", message: `${e.text} could not be fetched (${e.error}); the check went on without it.`, fix: "If the page needs it, check the URL; offline, fonts fall back to the next in the stack.", width: r.width });
+        if (/BLOCKED_BY_CLIENT/.test(e.error)) findings.push({ level: "info", code: "remote-failed", message: `${e.text} was not fetched: the check only reads from public addresses (GET, HEAD or OPTIONS), blocks WebSockets, and the page asked for something else; it went on without it.`, fix: "Load data and assets with plain GET requests from public URLs, or from files next to the chart; the checker does not forward request bodies or WebSocket messages.", width: r.width });
+        else findings.push({ level: "info", code: "remote-failed", message: `${e.text} could not be fetched (${e.error}); the check went on without it.`, fix: "If the page needs it, check the URL; offline, fonts fall back to the next in the stack.", width: r.width });
       }
     }
 
@@ -461,14 +517,19 @@ export async function check(options = {}) {
 
     // focus that shows nothing: one finding for the page
     if (r.unfocused.length) findings.push({ ...fromProbe({ code: "focus-invisible", what: r.unfocused[0], more: r.unfocused.length - 1 }, {}), width: r.width });
+
+    // Existing click selection with a temporary hover override, verified on an isolated page.
+    for (const f of r.selection.findings) findings.push({ ...fromProbe(f, {}), width: r.width });
+
   }
 
   const charts = results.flatMap((r) => r.seen.charts.map((c) => ({ width: r.width, ...c })));
+  const selectionAudits = results.flatMap((r) => r.selection.tested ? [{ width: r.width, ...r.selection.tested }] : []);
   const interactions = results.flatMap((r) => r.interactions);
   const swept = results.flatMap((r) => r.swept.map(({ width, breakpoint, slats, jumps }) => ({ width, breakpoint: !!breakpoint, slats, jumps: jumps.length }))).sort((a, b) => b.width - a.width);
   timings.widths = Object.fromEntries(results.map((r) => [r.width, r.ms]));
 
-  return finish({ ...base, browser: launched.name, findings, charts, interactions, interactedAt: wantInteract ? widths[0] : null, swept, screenshots, timings, started });
+  return finish({ ...base, browser: launched.name, findings, charts, interactions, interactedAt: wantInteract ? widths[0] : null, selectionAudits, swept, screenshots, timings, started });
 }
 
 // Merges the same finding at several widths, sorts errors first, and writes the report
@@ -498,6 +559,7 @@ function finish({ findings, started, timings, ...rest }) {
     charts: rest.charts ?? [],
     interactions: rest.interactions ?? [],
     interactedAt: rest.interactedAt ?? null,
+    selectionAudits: rest.selectionAudits ?? [],
     swept: rest.swept ?? [],
     screenshots: rest.screenshots ?? [],
     timings,

package/src/check/inpage.js

@@ -1078,10 +1078,10 @@ export function install() {
   // point reaches it and something in the slat takes the pointer, something covers it: { covered } says what (another
   // slat of its Plot, or an element). When nothing in it takes the pointer (the page reads the pointer around the
   // chart), the first point on its first mark, or its center.
-  function pointAt(n, across = 0.5) {
+  function pointAt(n, across = 0.5, scroll = true) {
 
     const slat = window.__rhpTargets[n];
-    slat.scrollIntoView({ block: "center", inline: "center", behavior: "instant" });
+    if (scroll) slat.scrollIntoView({ block: "center", inline: "center", behavior: "instant" });
     const marks = [...slat.querySelectorAll(MARKS + ", .rhp-cell")].filter(visible)
       .map((m) => ({ m, r: m.getBoundingClientRect(), pointer: getComputedStyle(m).cursor === "pointer" }))
       .filter(({ r }) => r.width * r.height > 0);

package/src/check/interact.js

@@ -5,7 +5,7 @@
 // look), what threw, and what moved: a control other than the one used, a chart's top, or the plot while a slat is
 // lit (the layout jumps); for a tap, also whether the reader sees none of the text it changed (unseen): all of it lies
 // outside the window.
-import { decode } from "./png.js";
+import { seenPixels } from "./png.js";
 
 const changes = (seen) => {
 
@@ -20,24 +20,6 @@ const changes = (seen) => {
   return parts.join(", ");
 };
 
-// How many pixels of two screenshots of one box differ enough to see (their channels by more than 24 in all: a
-// tint of 6% of the ink over the paper shows, drawing one page twice changes nothing)
-function seenPixels(a, b) {
-
-  if (a.equals(b)) return 0;
-
-  const x = decode(a);
-  const y = decode(b);
-  if (x.width !== y.width || x.height !== y.height) return Infinity;
-
-  let n = 0;
-  for (let i = 0; i < x.data.length; i += 4) {
-    if (Math.abs(x.data[i] - y.data[i]) + Math.abs(x.data[i + 1] - y.data[i + 1]) + Math.abs(x.data[i + 2] - y.data[i + 2]) > 24) n++;
-  }
-
-  return n;
-}
-
 // Tab through the page (up to 8 stops, until it comes back to one): each stop's box, with room around it for an
 // outline, is pictured focused and then blurred (Tab goes on from an element blurred). A stop where under 20 pixels
 // change shows the keyboard reader nothing (outline: none, and nothing in its place).

package/src/check/network.js

@@ -0,0 +1,168 @@
+// What a checked page may reach on the network. The page runs code the checker did not write, so its requests to the
+// web are made here, in Node, under three rules:
+//   - only public addresses: never loopback, private, link-local, shared (CGNAT), multicast or reserved ones, checked
+//     on the address actually connected to (so neither a redirect nor a DNS answer that changes can reach one)
+//   - only requests that read: GET, HEAD and OPTIONS (a chart reads fonts, scripts, styles, images and data while it
+//     renders; it has no reason to send anything)
+//   - the same 5 seconds and 5 redirects as before
+import dns from "dns";
+import net from "net";
+import http from "http";
+import https from "https";
+import zlib from "zlib";
+
+const MAX_BODY = 64 * 1024 * 1024;
+
+const BLOCKED = new net.BlockList();
+for (const [address, prefix] of [
+  ["0.0.0.0", 8], ["10.0.0.0", 8], ["100.64.0.0", 10], ["127.0.0.0", 8], ["169.254.0.0", 16], ["172.16.0.0", 12],
+  ["192.0.0.0", 24], ["192.0.2.0", 24], ["192.88.99.0", 24], ["192.168.0.0", 16], ["198.18.0.0", 15],
+  ["198.51.100.0", 24], ["203.0.113.0", 24], ["224.0.0.0", 4], ["240.0.0.0", 4],
+]) BLOCKED.addSubnet(address, prefix, "ipv4");
+for (const [address, prefix] of [
+  ["::", 128], ["::1", 128], ["64:ff9b::", 96], ["100::", 64], ["2001:db8::", 32], ["fc00::", 7], ["fe80::", 10], ["ff00::", 8],
+]) BLOCKED.addSubnet(address, prefix, "ipv6");
+
+// Whether an IP address is one a page may not reach (an IPv4 address written as IPv6 is judged as IPv4)
+export function isPrivate(ip) {
+
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/i.exec(ip);
+  if (mapped) return BLOCKED.check(mapped[1], "ipv4");
+  // URL canonicalizes IPv6 spellings, including dotted and expanded IPv4-mapped addresses.
+  if (net.isIP(ip) === 6) {
+    const canonical = new URL(`http://[${ip}]/`).hostname.slice(1, -1);
+    const hex = /^::ffff:([\da-f]+):([\da-f]+)$/i.exec(canonical);
+    if (hex) {
+      const a = parseInt(hex[1], 16), b = parseInt(hex[2], 16);
+      return BLOCKED.check(`${a >> 8}.${a & 255}.${b >> 8}.${b & 255}`, "ipv4");
+    }
+  }
+  const family = net.isIP(ip);
+  if (!family) return true;
+
+  return BLOCKED.check(ip, family === 4 ? "ipv4" : "ipv6");
+}
+
+const blocked = (why) => Object.assign(new Error(why), { code: "EBLOCKED" });
+
+// dns.lookup that refuses names answering with an address a page may not reach. Node calls it for every connection,
+// so the address checked is the one connected to.
+function publicLookup(hostname, options, callback) {
+
+  dns.lookup(hostname, { ...options, all: true }, (err, addresses) => {
+    if (err) return callback(err);
+    const bad = addresses.find((a) => isPrivate(a.address));
+    if (bad) return callback(blocked(`${hostname} is at ${bad.address}, which is not a public address`));
+    if (options.all) return callback(null, addresses);
+    return callback(null, addresses[0].address, addresses[0].family);
+  });
+}
+
+export const READ_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+
+// Request headers that belong to one connection, or that would have the server compress (the body is handed to the
+// browser as it is, so it is asked for plain)
+const DROP_REQUEST = new Set(["host", "connection", "keep-alive", "proxy-connection", "transfer-encoding", "upgrade", "accept-encoding", "content-length"]);
+const DROP_RESPONSE = new Set(["connection", "keep-alive", "transfer-encoding", "content-encoding", "content-length"]);
+
+function once(url, method, headers, deadline) {
+
+  return new Promise((resolve) => {
+    const u = new URL(url);
+    const host = u.hostname.replace(/^\[|\]$/g, "");
+    if (net.isIP(host) && isPrivate(host)) return resolve({ error: `${host} is not a public address`, blocked: true });
+    const left = deadline - Date.now();
+    if (left <= 0) return resolve({ error: "Timeout" });
+    const sendHeaders = { "accept-encoding": "identity" };
+    for (const [k, v] of Object.entries(headers)) if (!DROP_REQUEST.has(k.toLowerCase())) sendHeaders[k] = v;
+    let timer;
+    let done = false;
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const req = (u.protocol === "https:" ? https : http).request(u, { method, headers: sendHeaders, lookup: publicLookup }, (res) => {
+      const chunks = [];
+      let size = 0;
+      res.on("data", (c) => {
+        size += c.length;
+        if (size > MAX_BODY) req.destroy(new Error("Response exceeds 64 MB"));
+        else chunks.push(c);
+      });
+      res.on("end", () => {
+        if (done) return;
+        try {
+          let body = Buffer.concat(chunks);
+          // Some servers compress even when identity was requested.
+          const encoding = String(res.headers["content-encoding"] ?? "identity").toLowerCase();
+          const decode = { gzip: zlib.gunzipSync, deflate: zlib.inflateSync, br: zlib.brotliDecompressSync }[encoding];
+          if (decode) body = decode(body, { maxOutputLength: MAX_BODY });
+          else if (encoding !== "identity") throw new Error(`Unsupported content encoding: ${encoding}`);
+          finish({ status: res.statusCode, headers: res.headers, body });
+        } catch (e) {
+          finish({ error: e.message });
+        }
+      });
+      res.on("error", (e) => finish({ error: e.message }));
+    });
+    // One wall-clock deadline covers DNS, headers, the body, and every redirect.
+    timer = setTimeout(() => req.destroy(new Error("Timeout while fetching chart asset")), left);
+    req.on("error", (e) => finish({ error: e.message, blocked: e.code === "EBLOCKED" }));
+    req.end();
+  });
+}
+
+// Fetches a URL for the page: { status, headers, body }, or { error, blocked } when it is not allowed or fails
+export async function fetchPublic(url, { method = "GET", headers = {}, timeout = 5000, maxRedirects = 5 } = {}) {
+
+  method = method.toUpperCase();
+  if (!READ_METHODS.has(method)) return { error: `${method} requests are not sent: the check only reads from the web`, blocked: true };
+
+  const deadline = Date.now() + timeout;
+  let current = url;
+
+  for (let hop = 0; ; hop++) {
+    if (!/^https?:$/.test(new URL(current).protocol)) return { error: `${new URL(current).protocol} is not fetched`, blocked: true };
+    const got = await once(current, method, headers, deadline);
+    if (got.error) return got;
+    const location = got.headers.location;
+    if (got.status >= 300 && got.status < 400 && location && got.status !== 304) {
+      if (hop >= maxRedirects) return { error: `More than ${maxRedirects} redirects` };
+      const next = new URL(location, current);
+      if (next.origin !== new URL(current).origin) {
+        headers = Object.fromEntries(Object.entries(headers).filter(([k]) => !["authorization", "cookie", "proxy-authorization"].includes(k.toLowerCase())));
+      }
+      current = next.href;
+      continue;
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(got.headers)) if (!DROP_RESPONSE.has(k)) out[k] = Array.isArray(v) ? v.join(", ") : String(v);
+    return { status: got.status, headers: out, body: got.body };
+  }
+}
+
+// A final network fence for renderer traffic not handled by Playwright's page routes (for example worker sockets).
+// Known HTTP asset requests are fulfilled by the Node fetcher before reaching this proxy.
+// Nothing accepted here is forwarded, and Chromium must proxy loopback traffic too.
+export async function denyBrowserNetwork(onBlocked) {
+  const deny = (request, socket) => {
+    onBlocked(request.url);
+    socket.destroy();
+  };
+  const server = http.createServer((request, response) => {
+    onBlocked(request.url);
+    response.writeHead(403).end();
+  });
+  server.on("connect", deny);
+  server.on("upgrade", deny);
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  return {
+    proxy: { server: `http://127.0.0.1:${server.address().port}`, bypass: "<-loopback>" },
+    close: () => new Promise((resolve) => { server.close(resolve); server.closeAllConnections(); }),
+  };
+}

package/src/check/png.js

@@ -96,3 +96,21 @@ export function pixelsIn(image, { left, top, right, bottom }) {
 
   return out;
 }
+
+// How many pixels of two screenshots of one box differ enough to see (their channels by more than 24 in all: a
+// tint of 6% of the ink over the paper shows, drawing one page twice changes nothing)
+export function seenPixels(a, b) {
+
+  if (a.equals(b)) return 0;
+
+  const x = decode(a);
+  const y = decode(b);
+  if (x.width !== y.width || x.height !== y.height) return Infinity;
+
+  let n = 0;
+  for (let i = 0; i < x.data.length; i += 4) {
+    if (Math.abs(x.data[i] - y.data[i]) + Math.abs(x.data[i + 1] - y.data[i + 1]) + Math.abs(x.data[i + 2] - y.data[i + 2]) > 24) n++;
+  }
+
+  return n;
+}

package/src/check/selection.js

@@ -0,0 +1,123 @@
+// A conditional audit of an existing click selection with a temporary hover override.
+// No click selection or no temporary hover means there is no interaction policy to repair here.
+// Run on a disposable page: clicks must not change the starting state of the normal interaction pass.
+import { seenPixels } from "./png.js";
+
+const SAME = 20;
+const same = (a, b) => seenPixels(a, b) < SAME;
+const name = (s) => `slat ${s.index} of ${s.of}${s.name ? ` (${s.name})` : ""}`;
+
+// Safe space inside this chart's poster, outside every chart and every control.
+// Pointing at text is safe; clicking a link, a legend button or another chart is not a reset gesture.
+function beside(target) {
+  const slat = window.__rhpTargets[target];
+  const poster = slat?.closest(".poster, figure");
+  if (!poster) return null;
+  const busy = "a, button, input, select, textarea, label, summary, [role], [tabindex], [contenteditable]";
+  const box = poster.getBoundingClientRect();
+  let margin = null;
+  for (let y = Math.max(12, box.top + 6); y < Math.min(innerHeight - 12, box.bottom - 6); y += 16) {
+    for (let x = Math.max(12, box.left + 6); x < Math.min(innerWidth - 12, box.right - 6); x += 16) {
+      const el = document.elementFromPoint(x, y);
+      if (!el || !poster.contains(el) || el.closest(".rhp-chart") || el.closest(busy)) continue;
+      const text = [...el.childNodes].some((n) => n.nodeType === 3 && n.textContent.trim());
+      const point = { x, y, what: text ? `"${el.textContent.trim().replace(/\s+/g, " ").slice(0, 40)}"` : "the poster's margin" };
+      if (text) return point;
+      margin ??= point;
+    }
+  }
+  return margin;
+}
+
+export async function selectionBehavior(page, { events }) {
+  const findings = [];
+  const audit = { findings, tested: null };
+  const start = events.length;
+  let doing = "checking existing selection and hover";
+  const settle = async () => {
+    const state = await page.evaluate(() => window.__rhpProbe.settle(1000));
+    if (!state.rest) throw new Error("The page is moving");
+  };
+  const look = async () => {
+    await settle();
+    return page.screenshot({ animations: "disabled", scale: "css" });
+  };
+  const away = async () => {
+    await page.mouse.move(-1, -1);
+    await settle();
+  };
+  const pointAt = (s) => page.evaluate((n) => window.__rhpProbe.pointAt(n, 0.5, false), s.target);
+  try {
+    // Use reachable marks, including marks inside a slat, from the main Plot.
+    // Keep the window still throughout the sequence so scrolling and sticky readouts cannot mimic a state change.
+    const slats = await page.evaluate(() => window.__rhpProbe.sweepTargets(12));
+    if (slats.length < 2) return audit;
+    await page.evaluate((n) => window.__rhpProbe.pointAt(n), slats[0].target);
+    await away();
+    const position = await page.evaluate(() => [scrollX, scrollY]);
+    const candidates = [];
+    for (const s of slats) {
+      const point = await pointAt(s);
+      if (point.covered) continue;
+      const safe = await page.evaluate(({ x, y }) => !document.elementFromPoint(x, y)?.closest("a, button, input, select, textarea, summary, [role=button], [role=slider], [contenteditable]"), point);
+      if (safe) candidates.push(s);
+      if (candidates.length === 3) break;
+    }
+    if (candidates.length < 2) return audit;
+    const off = await page.evaluate(beside, candidates[0].target);
+    if (!off) return audit;
+    const rest = await look();
+    if (!same(rest, await look())) return audit;
+    // At most three candidates, so an initial meaningful default on the first mark does not hide click selection.
+    for (const chosen of candidates) {
+      doing = `click ${name(chosen)}`;
+      const at = await pointAt(chosen);
+      if (at.covered) continue;
+      await page.mouse.click(at.x, at.y);
+      await away();
+      const pinned = await look();
+      if (same(rest, pinned)) continue;
+      for (const preview of candidates.filter((s) => s !== chosen)) {
+        doing = `hover ${name(preview)} after clicking ${name(chosen)}`;
+        const over = await pointAt(preview);
+        if (over.covered) continue;
+        await page.mouse.move(over.x, over.y);
+        const hovered = await look();
+        if (same(pinned, hovered)) continue;
+        await page.mouse.move(off.x, off.y);
+        const offChart = await look();
+        await away();
+        const restored = await look();
+        // Prove that click pins a state and hover temporarily overrides it.
+        // A hover-only chart, a click-only chart, or a scrubber that retains its last point does not qualify.
+        if (!same(pinned, restored)) continue;
+        const here = await page.evaluate(() => [scrollX, scrollY]);
+        if (position.some((v, i) => v !== here[i]) || !same(restored, await look())) return audit;
+        // Compare with the selected state at the same outside-chart pointer position (including CSS :hover).
+        await page.mouse.move(off.x, off.y);
+        const selected = await look();
+        const hoverBroken = !same(selected, offChart);
+        // This click is inside the poster, outside every chart and control.
+        doing = `click beside the chart after selecting ${name(chosen)}`;
+        await page.mouse.click(off.x, off.y);
+        await away();
+        const reset = await look();
+        const resetBroken = !same(rest, reset);
+        const end = await page.evaluate(() => [scrollX, scrollY]);
+        if (position.some((v, i) => v !== end[i]) || !same(reset, await look())) return audit;
+        audit.tested = { selected: name(chosen), preview: name(preview), hoverRestoresSelection: !hoverBroken, clickRestoresInitial: !resetBroken };
+        if (hoverBroken) findings.push({ code: "selection-hover-stays", target: name(preview), selected: name(chosen), what: off.what });
+        if (resetBroken) findings.push({ code: "selection-reset", target: name(chosen), what: off.what });
+        return audit;
+      }
+    }
+  } catch {
+    // Moving pages, covered marks and navigation cannot establish this interaction contract.
+    // The normal interaction pass reports failures to reach marks and the page's exceptions.
+  } finally {
+    for (const e of events.slice(start)) {
+      if ((e.kind === "pageerror" || e.kind === "console-error") && !e.during) e.during = doing;
+    }
+  }
+  return audit;
+}