@mark1russell7/site-pages 0.1.6 → 0.1.8

package/build/cli.js

@@ -1,12 +1,682 @@
 #!/usr/bin/env node
-import { a as runCli } from "./build-Dr35nErd.js";
+import { a as runCli } from "./build-CD2wc7Yl.js";
+import { spawn } from "node:child_process";
+import { appendFileSync, createReadStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { delimiter, extname, isAbsolute, join, normalize, resolve, sep } from "node:path";
+import { parseArgs } from "node:util";
+import { homedir, tmpdir } from "node:os";
+import { createServer } from "node:http";
+// src/check/browser.ts
+/**
+* A small client of the Chrome DevTools protocol for the `check` command. It starts a Chromium
+* browser (Chrome, Edge or the Chromium of Playwright) in headless mode and drives one page. It
+* uses only Node.js, so the check needs no package install.
+*/
+/** The paths that `findBrowser` examines after the option and the Playwright folder. */
+function systemBrowsers(platform, env) {
+	if (platform === "win32") return [
+		env["PROGRAMFILES"],
+		env["PROGRAMFILES(X86)"],
+		env["LOCALAPPDATA"]
+	].filter((root) => !!root).flatMap((root) => [join(root, "Google/Chrome/Application/chrome.exe"), join(root, "Microsoft/Edge/Application/msedge.exe")]);
+	if (platform === "darwin") return [
+		"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+		"/Applications/Chromium.app/Contents/MacOS/Chromium",
+		"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+	];
+	const names = [
+		"google-chrome",
+		"google-chrome-stable",
+		"chromium",
+		"chromium-browser",
+		"microsoft-edge"
+	];
+	const dirs = (env["PATH"] ?? "").split(delimiter).filter(Boolean);
+	return names.flatMap((name) => dirs.map((dir) => join(dir, name)));
+}
+/** The Chromium of the newest `chromium-<n>` folder of Playwright, or undefined. */
+function playwrightChromium(platform, env) {
+	const root = env["PLAYWRIGHT_BROWSERS_PATH"] || (platform === "win32" ? join(env["LOCALAPPDATA"] ?? homedir(), "ms-playwright") : platform === "darwin" ? join(homedir(), "Library/Caches/ms-playwright") : join(homedir(), ".cache/ms-playwright"));
+	if (!existsSync(root)) return void 0;
+	const builds = readdirSync(root).map((name) => /^chromium-(\d+)$/.exec(name)).filter((match) => match !== null).sort((a, b) => Number(b[1]) - Number(a[1]));
+	for (const [folder] of builds) for (const sub of readdirSync(join(root, folder))) {
+		const found = (platform === "win32" ? [join(root, folder, sub, "chrome.exe")] : platform === "darwin" ? [join(root, folder, sub, "Chromium.app/Contents/MacOS/Chromium"), join(root, folder, sub, "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing")] : [join(root, folder, sub, "chrome")]).find((file) => existsSync(file));
+		if (found) return found;
+	}
+}
+/**
+* This function finds a Chromium browser. It examines the given path, then `$SITE_CHECK_BROWSER`,
+* then the newest Chromium of Playwright, then a Chrome or an Edge of the system.
+*
+* @returns the path of the executable, or undefined when there is none
+*/
+function findBrowser(given, env = process.env, platform = process.platform) {
+	const named = given || env["SITE_CHECK_BROWSER"];
+	if (named) return named;
+	return playwrightChromium(platform, env) ?? systemBrowsers(platform, env).find((file) => existsSync(file));
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* This function starts the browser in headless mode with a new profile, and connects to its page.
+* The browser picks a free port, so two checks can run at the same time.
+*
+* @throws Error when the browser does not start in `timeoutMs`
+*/
+async function launch(executable, timeoutMs = 3e4) {
+	const profile = mkdtempSync(join(tmpdir(), "site-check-"));
+	const args = [
+		"--headless=new",
+		"--remote-debugging-port=0",
+		`--user-data-dir=${profile}`,
+		"--no-first-run",
+		"--no-default-browser-check",
+		"--disable-gpu",
+		"--disable-extensions",
+		"--disable-background-networking",
+		"--disable-sync",
+		"--hide-scrollbars",
+		"--mute-audio",
+		...process.platform === "linux" ? ["--no-sandbox"] : [],
+		"about:blank"
+	];
+	const child = spawn(executable, args, { stdio: "ignore" });
+	let exited;
+	child.once("exit", (code, signal) => exited = `the browser stopped (code ${code}, signal ${signal})`);
+	child.once("error", (error) => exited = `the browser did not start: ${error.message}`);
+	const stop = async () => {
+		if (child.exitCode === null && child.signalCode === null) {
+			child.kill();
+			await Promise.race([new Promise((resolve) => child.once("exit", resolve)), sleep(5e3)]);
+		}
+		rmSync(profile, {
+			recursive: true,
+			force: true,
+			maxRetries: 5,
+			retryDelay: 200
+		});
+	};
+	try {
+		const portFile = join(profile, "DevToolsActivePort");
+		const end = Date.now() + timeoutMs;
+		let port = "";
+		while (port === "") {
+			if (exited !== void 0) throw new Error(`${executable}: ${exited}`);
+			if (Date.now() > end) throw new Error(`${executable}: no DevTools port after ${timeoutMs} ms`);
+			if (existsSync(portFile)) port = readFileSync(portFile, "utf8").split("\n")[0]?.trim() ?? "";
+			if (port === "") await sleep(100);
+		}
+		let target;
+		while (target === void 0) {
+			target = (await (await fetch(`http://127.0.0.1:${port}/json/list`)).json()).find((entry) => entry.type === "page");
+			if (target === void 0) {
+				if (Date.now() > end) throw new Error(`${executable}: no page target after ${timeoutMs} ms`);
+				await sleep(100);
+			}
+		}
+		const page = await connect(target.webSocketDebuggerUrl);
+		return {
+			page: page.page,
+			close: async () => {
+				page.close();
+				await stop();
+			}
+		};
+	} catch (error) {
+		await stop();
+		throw error;
+	}
+}
+async function connect(url) {
+	const socket = new WebSocket(url);
+	await new Promise((resolve, reject) => {
+		socket.addEventListener("open", () => resolve(), { once: true });
+		socket.addEventListener("error", () => reject(/* @__PURE__ */ new Error(`no connection to ${url}`)), { once: true });
+	});
+	let sequence = 0;
+	const pending = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	socket.addEventListener("message", (event) => {
+		const message = JSON.parse(String(event.data));
+		if (message.id !== void 0) {
+			const call = pending.get(message.id);
+			pending.delete(message.id);
+			if (message.error) call?.reject(new Error(message.error.message));
+			else call?.resolve(message.result ?? {});
+		} else if (message.method) for (const listener of listeners.get(message.method) ?? []) listener(message.params ?? {});
+	});
+	socket.addEventListener("close", () => {
+		for (const call of pending.values()) call.reject(/* @__PURE__ */ new Error("the browser closed the connection"));
+		pending.clear();
+	});
+	const page = {
+		send: (method, params = {}) => new Promise((resolve, reject) => {
+			const id = ++sequence;
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			socket.send(JSON.stringify({
+				id,
+				method,
+				params
+			}));
+		}),
+		on: (method, listener) => listeners.set(method, [...listeners.get(method) ?? [], listener]),
+		once: (method, ms) => new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				remove();
+				reject(/* @__PURE__ */ new Error(`no ${method} after ${ms} ms`));
+			}, ms);
+			const listener = (params) => {
+				clearTimeout(timer);
+				remove();
+				resolve(params);
+			};
+			const remove = () => listeners.set(method, (listeners.get(method) ?? []).filter((entry) => entry !== listener));
+			page.on(method, listener);
+		}),
+		evaluate: async (expression) => {
+			const reply = await page.send("Runtime.evaluate", {
+				expression,
+				awaitPromise: true,
+				returnByValue: true
+			});
+			if (reply.exceptionDetails) throw new Error(reply.exceptionDetails.exception?.description ?? reply.exceptionDetails.text ?? "the expression failed");
+			return reply.result?.value;
+		}
+	};
+	return {
+		page,
+		close: () => socket.close()
+	};
+}
+// src/check/measure.ts
+/**
+* This expression measures the page. An element counts as past the edge when its right side is
+* more than half a pixel past the width of the document. These elements do not count:
+* - an element in a container that scrolls or clips (`overflow-x` other than `visible`, below `body`),
+* - an element of zero size, a hidden element, or a fixed element that is fully past the edge (a closed drawer),
+* - an element in `.sr`, `.sr-only`, `.visually-hidden` or `.skip` (text for screen readers and skip links),
+* - an element in a `pre`, other than the `pre` itself.
+* Of a chain of elements past the edge, only the outermost one counts.
+*/
+const MEASURE = `(() => {
+  const root = document.documentElement;
+  const w = root.clientWidth;
+  const name = (e) => e.tagName.toLowerCase() + (e.id ? "#" + e.id : "") + (typeof e.className === "string" && e.className.trim() ? "." + e.className.trim().split(/\\s+/).slice(0, 3).join(".") : "");
+  const inScroller = (e) => {
+    for (let p = e.parentElement; p && p !== document.body && p !== root; p = p.parentElement) {
+      if (getComputedStyle(p).overflowX !== "visible") return true;
+    }
+    return false;
+  };
+  const counts = (e) => {
+    const r = e.getBoundingClientRect();
+    if (r.width === 0 || r.height === 0 || r.right <= w + 0.5) return false;
+    if (e.closest(".sr,.sr-only,.visually-hidden,.skip")) return false;
+    if (e.closest("pre") && e.tagName !== "PRE") return false;
+    const s = getComputedStyle(e);
+    if (s.visibility === "hidden" || s.display === "none") return false;
+    if (s.position === "fixed" && r.left >= w) return false;
+    return !inScroller(e);
+  };
+  const over = new Set([...document.querySelectorAll("body *")].filter(counts));
+  const past = [...over]
+    .filter((e) => { for (let p = e.parentElement; p; p = p.parentElement) if (over.has(p)) return false; return true; })
+    .map((e) => name(e) + " right=" + Math.round(e.getBoundingClientRect().right));
+  const clipped = [...document.querySelectorAll("textarea")]
+    .filter((e) => { const s = getComputedStyle(e); return (s.overflowY === "hidden" || s.overflowY === "clip") && e.getBoundingClientRect().height > 0 && e.scrollHeight > e.clientHeight + 1; })
+    .map((e) => name(e) + " " + e.scrollHeight + ">" + e.clientHeight);
+  return {
+    innerWidth,
+    scrollWidth: root.scrollWidth,
+    height: Math.max(root.scrollHeight, document.body ? document.body.scrollHeight : 0),
+    text: (document.body ? document.body.innerText : "").trim().length,
+    past: past.slice(0, 8),
+    clipped: clipped.slice(0, 8),
+  };
+})()`;
+/**
+* This function wraps the code of a probe file into an expression. The code is the body of an async
+* function with these names:
+* - `check(name, ok, detail)` records a check,
+* - `wait(ms)` waits,
+* - `until(fn, ms)` waits until `fn()` gives a true value, at most `ms` (default 5000), and returns the value,
+* - `$(selector)` and `$$(selector)` find elements,
+* - `type(element, text)` writes the text into an input or a text area, with an `input` event,
+* - `click(element)` clicks an element, or the first element of a selector.
+* An exception stops the probe, and it counts as a failed check.
+*/
+function probeExpression(code) {
+	return `(async () => {
+  const __checks = [];
+  const __text = (v) => { if (v === undefined) return undefined; if (typeof v === "string") return v; try { return JSON.stringify(v); } catch { return String(v); } };
+  const check = (name, ok, detail) => { __checks.push({ name: String(name), ok: !!ok, ...(ok ? {} : { detail: __text(detail) }) }); return !!ok; };
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  const until = async (fn, ms = 5000) => { const end = Date.now() + ms; for (;;) { const v = await fn(); if (v) return v; if (Date.now() > end) return v; await wait(50); } };
+  const $ = (s) => document.querySelector(s);
+  const $$ = (s) => [...document.querySelectorAll(s)];
+  const __el = (e) => { const el = typeof e === "string" ? document.querySelector(e) : e; if (!el) throw new Error("no element: " + e); return el; };
+  const type = (e, text) => { const el = __el(e); el.focus(); el.value = text; el.dispatchEvent(new Event("input", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); };
+  const click = (e) => __el(e).click();
+  try {
+    await (async () => {
+${code}
+    })();
+  } catch (e) {
+    __checks.push({ name: "the probe runs to its end", ok: false, detail: String((e && e.stack) || e) });
+  }
+  return __checks;
+})()`;
+}
+// src/check/serve.ts
+/**
+* A static file server for the `check` command. It serves a built site folder at the path of the
+* site home, as GitHub Pages does. Thus the links of the site work as on the live site.
+*/
+const TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".wasm": "application/wasm",
+	".txt": "text/plain; charset=utf-8",
+	".md": "text/markdown; charset=utf-8",
+	".xml": "application/xml",
+	".webmanifest": "application/manifest+json",
+	".map": "application/json; charset=utf-8"
+};
+/**
+* This function maps the path of a request to a file of the folder, as GitHub Pages does. A folder
+* gives its `index.html`. For a path with no extension, the function also tries `<path>.html`.
+*
+* @returns the absolute file, or undefined when the path is outside the base or the file is missing
+*/
+function resolveFile(root, base, pathname) {
+	let decoded;
+	try {
+		decoded = decodeURIComponent(pathname);
+	} catch {
+		return;
+	}
+	const home = base.endsWith("/") ? base : `${base}/`;
+	if (decoded === home.slice(0, -1)) decoded = home;
+	if (!decoded.startsWith(home)) return void 0;
+	const top = resolve(root);
+	const file = normalize(join(top, decoded.slice(home.length)));
+	if (file !== top && !file.startsWith(top + sep)) return void 0;
+	return [
+		file,
+		join(file, "index.html"),
+		`${file}.html`
+	].find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
+}
+/**
+* This function serves the folder at `base` on a free port of 127.0.0.1. A missing file gives the
+* status 404 with the `404.html` of the folder, when it has one.
+*/
+async function serve(root, base) {
+	const server = createServer((request, response) => {
+		const pathname = new URL(request.url ?? "/", "http://localhost").pathname;
+		const home = base.endsWith("/") ? base : `${base}/`;
+		if (pathname === home.slice(0, -1) && home !== "/") {
+			response.writeHead(301, { location: home }).end();
+			return;
+		}
+		const file = resolveFile(root, base, pathname);
+		const missing = join(resolve(root), "404.html");
+		const send = file ?? (existsSync(missing) ? missing : void 0);
+		if (send === void 0) {
+			response.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end(`404: ${pathname}\n`);
+			return;
+		}
+		response.writeHead(file ? 200 : 404, {
+			"content-type": TYPES[extname(send).toLowerCase()] ?? "application/octet-stream",
+			"cache-control": "no-store"
+		});
+		createReadStream(send).pipe(response);
+	});
+	await new Promise((done, fail) => {
+		server.once("error", fail);
+		server.listen(0, "127.0.0.1", () => done());
+	});
+	const address = server.address();
+	if (address === null || typeof address === "string") throw new Error("the server has no port");
+	return {
+		url: `http://127.0.0.1:${address.port}${base.endsWith("/") ? base : `${base}/`}`,
+		close: () => new Promise((done) => server.close(() => done()))
+	};
+}
+// src/check/check.ts
+/**
+* The `site-pages check` command. It opens the pages of a built site (or of a live URL) in a
+* headless Chromium at phone and desktop widths, in the light and the dark scheme.
+*
+* A view fails when the page is wider than the screen or an element goes past the right edge. It
+* also fails when a text area hides its text or the page shows no text. A console error, an
+* exception, a failed request of the site and a failed check of the probe also fail it. The command
+* writes a screenshot of each view.
+*/
+/** This function gives the file name part of a page: `/` is `home`, `/releases/` is `releases`. */
+function pageSlug(page) {
+	const slug = page.replace(/^\/+|\/+$/g, "").replace(/[^A-Za-z0-9._-]+/g, "_");
+	return slug === "" ? "home" : slug;
+}
+/**
+* This function checks the site. It starts one browser and, for `out`, one server, and stops both at
+* the end.
+*
+* @throws Error when there is no browser, or the browser does not start
+*/
+async function checkSite(options) {
+	const log = options.log ?? (() => {});
+	const executable = findBrowser(options.browser);
+	if (executable === void 0) throw new Error("no Chromium browser was found: give --browser, set SITE_CHECK_BROWSER, or install the Chromium of Playwright");
+	if (options.pages.length === 0) throw new Error("no page to check");
+	const server = options.out !== void 0 ? await serve(options.out, options.base ?? "/") : void 0;
+	const home = server?.url ?? options.url;
+	if (home === void 0) throw new Error("give out or url");
+	const homeUrl = new URL(home.endsWith("/") ? home : `${home}/`);
+	const browser = await launch(executable, options.timeoutMs);
+	const views = [];
+	try {
+		const { page } = browser;
+		const events = watch(page, homeUrl.origin);
+		await Promise.all([
+			page.send("Page.enable"),
+			page.send("Runtime.enable"),
+			page.send("Network.enable")
+		]);
+		if (options.shots) mkdirSync(options.shots, { recursive: true });
+		for (const [index, path] of options.pages.entries()) {
+			const target = new URL(path.replace(/^\/+/, ""), homeUrl).href;
+			for (const width of options.widths) for (const scheme of options.schemes) {
+				const view = await checkView(page, events, {
+					target,
+					path,
+					width,
+					scheme,
+					withProbe: options.probe !== void 0 && index === 0 && scheme === options.schemes[0],
+					options
+				});
+				views.push(view);
+				log(`${view.ok ? "PASS" : "FAIL"} ${path} ${width} ${scheme}${view.measure ? ` scrollWidth=${view.measure.scrollWidth} innerWidth=${view.measure.innerWidth}` : ""}${view.probe ? ` probe ${view.probe.filter((c) => c.ok).length}/${view.probe.length}` : ""}${view.problems.length > 0 ? `\n  - ${view.problems.join("\n  - ")}` : ""}`);
+			}
+		}
+	} finally {
+		await browser.close();
+		await server?.close();
+	}
+	const result = {
+		ok: views.length > 0 && views.every((view) => view.ok),
+		url: homeUrl.href,
+		browser: executable,
+		views
+	};
+	if (options.shots) {
+		writeFileSync(join(options.shots, "report.json"), `${JSON.stringify(result, null, 2)}\n`);
+		writeFileSync(join(options.shots, "summary.md"), summary(result));
+	}
+	return result;
+}
+function watch(page, origin) {
+	let problems = [];
+	const urls = /* @__PURE__ */ new Map();
+	const own = (url) => {
+		try {
+			const parsed = new URL(url);
+			return parsed.origin === origin && parsed.pathname !== "/favicon.ico";
+		} catch {
+			return false;
+		}
+	};
+	page.on("Runtime.exceptionThrown", (params) => {
+		const details = params["exceptionDetails"];
+		problems.push(`exception: ${(details.exception?.description ?? details.text ?? "").split("\n")[0]}`);
+	});
+	page.on("Runtime.consoleAPICalled", (params) => {
+		if (params["type"] !== "error" && params["type"] !== "assert") return;
+		const args = params["args"] ?? [];
+		problems.push(`console.error: ${args.map((arg) => String(arg.value ?? arg.description ?? "")).join(" ").slice(0, 300)}`);
+	});
+	page.on("Network.requestWillBeSent", (params) => {
+		urls.set(String(params["requestId"]), String(params["request"].url));
+	});
+	page.on("Network.responseReceived", (params) => {
+		const response = params["response"];
+		if (response.status >= 400 && own(response.url)) problems.push(`HTTP ${response.status}: ${response.url}`);
+	});
+	page.on("Network.loadingFailed", (params) => {
+		const url = urls.get(String(params["requestId"])) ?? "";
+		if (own(url) && params["canceled"] !== true) problems.push(`request failed (${String(params["errorText"])}): ${url}`);
+	});
+	return {
+		reset: () => {
+			problems = [];
+		},
+		problems: () => [...new Set(problems)]
+	};
+}
+async function checkView(page, events, input) {
+	const { target, path, width, scheme, withProbe, options } = input;
+	const view = {
+		page: path,
+		width,
+		scheme,
+		ok: false,
+		problems: []
+	};
+	try {
+		await page.send("Emulation.setDeviceMetricsOverride", {
+			width,
+			height: 900,
+			deviceScaleFactor: 1,
+			mobile: width < 768
+		});
+		await page.send("Emulation.setEmulatedMedia", { features: [{
+			name: "prefers-color-scheme",
+			value: scheme
+		}] });
+		events.reset();
+		const loaded = page.once("Page.loadEventFired", options.timeoutMs);
+		const navigation = await page.send("Page.navigate", { url: target });
+		if (navigation.errorText) {
+			loaded.catch(() => {});
+			throw new Error(`the page did not open: ${navigation.errorText}`);
+		}
+		await loaded;
+		await page.evaluate("document.fonts ? document.fonts.ready.then(() => true) : true");
+		await new Promise((done) => setTimeout(done, options.settleMs));
+		const measure = await page.evaluate(MEASURE);
+		view.measure = measure;
+		if (measure.scrollWidth > width) view.problems.push(`the page is wider than the screen: ${measure.scrollWidth} > ${width}`);
+		for (const past of measure.past) view.problems.push(`past the right edge: ${past}`);
+		for (const clipped of measure.clipped) view.problems.push(`a text area hides its text: ${clipped}`);
+		if (measure.text === 0) view.problems.push("the page shows no text");
+		if (options.shots) {
+			const file = join(options.shots, `${pageSlug(path)}-${width}-${scheme}.png`);
+			const height = Math.min(Math.max(measure.height, 1), 8e3);
+			const shot = await page.send("Page.captureScreenshot", {
+				format: "png",
+				captureBeyondViewport: true,
+				clip: {
+					x: 0,
+					y: 0,
+					width,
+					height,
+					scale: 1
+				}
+			});
+			writeFileSync(file, Buffer.from(shot.data, "base64"));
+			view.shot = file;
+		}
+		if (withProbe && options.probe !== void 0) {
+			const checks = await page.evaluate(probeExpression(options.probe)) ?? [];
+			view.probe = checks;
+			if (checks.length === 0) view.problems.push("the probe made no check");
+			for (const check of checks.filter((entry) => !entry.ok)) view.problems.push(`probe: ${check.name}${check.detail ? ` (${check.detail})` : ""}`);
+		}
+	} catch (error) {
+		view.problems.push(error instanceof Error ? error.message : String(error));
+	}
+	view.problems.push(...events.problems());
+	view.ok = view.problems.length === 0;
+	return view;
+}
+/** This function makes a text safe for a cell of a Markdown table. It escapes `\`, `|`, `<` and `>`. It changes each new line to a space. */
+function cell(text) {
+	return text.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r?\n/g, " ");
+}
+/** This function gives the Markdown summary of a result, for the job summary of a workflow. */
+function summary(result) {
+	const failed = result.views.filter((view) => !view.ok);
+	return [
+		`### Site check: ${result.ok ? "passed" : "failed"}`,
+		"",
+		`${result.views.length - failed.length} of ${result.views.length} views passed, at ${result.url}.`,
+		"",
+		"| Page | Width | Scheme | Result | Problems |",
+		"| --- | ---: | --- | --- | --- |",
+		...result.views.map((view) => `| \`${view.page}\` | ${view.width} | ${view.scheme} | ${view.ok ? "pass" : "**fail**"}${view.probe ? ` (probe ${view.probe.filter((c) => c.ok).length}/${view.probe.length})` : ""} | ${view.problems.map(cell).join("<br>")} |`),
+		""
+	].join("\n");
+}
+const CHECK_HELP = `Usage: site-pages check (--out <dir> | --url <url>) [options]
+
+Opens the pages of the site in a headless Chromium at phone and desktop widths, in the light and
+the dark scheme, and fails when a page is wider than the screen, an element goes past the right
+edge, a text area hides its text, a page shows no text, or on a console error, an exception, a
+failed request of the site or a failed check of the probe.
+
+Options:
+  --out <dir>          The built site folder. The check serves it at --base.
+  --url <url>          The URL of a live site home, in place of --out
+  --repo <owner/name>  The GitHub repository, for the default base (default: $GITHUB_REPOSITORY)
+  --base </name/>      The path of the site home (default: "/<name>/", or "/" for <owner>.github.io)
+  --pages <paths>      The pages, from the site home, separated by commas (default: /)
+  --widths <px>        The widths, separated by commas (default: 360,400,1280)
+  --schemes <list>     light, dark or both (default: light,dark)
+  --probe <file>       A JavaScript file: the body of an async function with check(name, ok, detail),
+                       wait, until, $, $$, type and click. It runs on the first page, in the first
+                       scheme, at each width.
+  --shots <dir>        The folder for the screenshots, report.json and summary.md
+  --browser <file>     The Chromium executable (default: $SITE_CHECK_BROWSER, the Chromium of
+                       Playwright, else Chrome or Edge)
+  --settle <ms>        The wait after the load event (default: 1500)
+  --timeout <ms>       The time limit of a page load (default: 30000)
+  --help               Shows this text
+
+With $GITHUB_STEP_SUMMARY, the check adds its table to the job summary.
+`;
+/** This function runs the `check` command with its arguments, without the word `check`. */
+async function runCheckCli(argv, io) {
+	let values;
+	try {
+		({values} = parseArgs({
+			args: [...argv],
+			allowPositionals: false,
+			options: {
+				out: { type: "string" },
+				url: { type: "string" },
+				repo: { type: "string" },
+				base: { type: "string" },
+				pages: { type: "string" },
+				widths: { type: "string" },
+				schemes: { type: "string" },
+				probe: { type: "string" },
+				shots: { type: "string" },
+				browser: { type: "string" },
+				settle: { type: "string" },
+				timeout: { type: "string" },
+				help: { type: "boolean" }
+			}
+		}));
+	} catch (error) {
+		io.stderr(`site-pages check: ${error instanceof Error ? error.message : String(error)}\n\n${CHECK_HELP}`);
+		return 2;
+	}
+	if (values["help"]) {
+		io.stdout(CHECK_HELP);
+		return 0;
+	}
+	const usage = (message) => {
+		io.stderr(`site-pages check: ${message}\n\n${CHECK_HELP}`);
+		return 2;
+	};
+	const text = (key) => typeof values[key] === "string" ? values[key] : void 0;
+	const list = (key, fallback) => (text(key) ?? fallback).split(",").map((entry) => entry.trim()).filter(Boolean);
+	const out = text("out");
+	const url = text("url");
+	if (out === void 0 === (url === void 0)) return usage("give --out or --url, not both");
+	const widths = list("widths", "360,400,1280").map(Number);
+	if (widths.length === 0 || widths.some((width) => !Number.isInteger(width) || width < 200 || width > 4e3)) return usage("--widths must be whole numbers from 200 to 4000");
+	const schemes = list("schemes", "light,dark");
+	if (schemes.length === 0 || schemes.some((scheme) => scheme !== "light" && scheme !== "dark")) return usage("--schemes must be light, dark or both");
+	const pages = list("pages", "/");
+	if (pages.length === 0) return usage("--pages has no page");
+	const notPath = pages.find((entry) => entry.includes(":") || entry.includes("\\"));
+	if (notPath !== void 0) return usage(`a page is a path from the site home, not "${notPath}" (in Git Bash, set MSYS_NO_PATHCONV=1)`);
+	const settleMs = Number(text("settle") ?? 1500);
+	const timeoutMs = Number(text("timeout") ?? 3e4);
+	if (!(settleMs >= 0) || !(timeoutMs > 0)) return usage("--settle and --timeout must be numbers of milliseconds");
+	let base = text("base");
+	if (out !== void 0 && base === void 0) {
+		const name = (text("repo") ?? io.env["GITHUB_REPOSITORY"] ?? "").split("/")[1];
+		if (!name) return usage("give --base, --repo or set GITHUB_REPOSITORY");
+		base = /\.github\.io$/i.test(name) ? "/" : `/${name}/`;
+	}
+	if (base !== void 0) base = `/${base.replace(/^\/+|\/+$/g, "")}/`.replace(/^\/\/$/, "/");
+	const at = (file) => isAbsolute(file) ? file : resolve(io.cwd, file);
+	const probeFile = text("probe");
+	let probe;
+	if (probeFile !== void 0) try {
+		probe = readFileSync(at(probeFile), "utf8");
+	} catch (error) {
+		return usage(`the probe file ${probeFile} cannot be read: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const shots = text("shots");
+	const result = await checkSite({
+		out: out === void 0 ? void 0 : at(out),
+		base,
+		url,
+		pages,
+		widths,
+		schemes,
+		probe,
+		shots: shots === void 0 ? void 0 : at(shots),
+		browser: text("browser"),
+		settleMs,
+		timeoutMs,
+		log: (line) => io.stdout(`${line}\n`)
+	});
+	const failed = result.views.filter((view) => !view.ok).length;
+	io.stdout(`site-pages check: ${result.views.length - failed} of ${result.views.length} views passed (${result.browser}).\n`);
+	const step = io.env["GITHUB_STEP_SUMMARY"];
+	if (step) appendFileSync(step, summary(result));
+	return result.ok ? 0 : 1;
+}
 // src/cli.ts
-runCli(process.argv.slice(2), {
+const argv = process.argv.slice(2);
+const io = {
 	cwd: process.cwd(),
 	env: process.env,
 	stdout: (text) => process.stdout.write(text),
 	stderr: (text) => process.stderr.write(text)
-}).then((code) => {
+};
+(argv[0] === "check" ? runCheckCli(argv.slice(1), io) : runCli(argv, io)).then((code) => {
 	process.exitCode = code;
 }, (error) => {
 	process.stderr.write(`site-pages: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);