everyscreen 0.0.0-stage → 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,2958 @@
+#!/usr/bin/env node
+import { _ as gridUpdateSchema, a as checkNewDevice, c as listCatalogReplies, d as pickGridChanges, f as pickGridDevices, h as customDeviceSchema, i as checkDeviceRemoval, l as pickDeviceScreen, m as DEVICE_CATALOG, n as readDevicesFile, o as createPresetFromCustomDevice, p as replaceGrid, r as updateDevicesFile, s as findCatalogPreset, u as pickDeviceViewport } from "./devices-store-edScJDie.mjs";
+import { C as SCREENCAST, D as writeProblem, E as rejectInvalidRequest, T as ZOOM_SCREENCAST, a as createStepTitle, c as pickChosenPages, d as pickFailureMessage, f as pickOpenApp, h as hubFileSchema, i as createShotPath, l as pickDeviceIds, m as countDeviceStatuses, n as createCommandRunStep, o as listDeviceFailures, p as summarizeCommand, r as createReplyLine, s as pickCheckDevice, t as countUnits, u as pickErrorMessage, v as HUB_FILE_PATH, w as STORE_FOLDER, x as LIVE_PATH, y as HUB_HOST } from "./commands-logic-DVWfSe3O.mjs";
+import { i as writeStoredFile, n as readStoredBytes, r as readStoredFile, t as runOneAtATime } from "./run-one-at-a-time-BeV_a3Fm.mjs";
+import { _ as listFindings, a as readRun, c as runOriginSchema, d as isRunOpen, f as pickStepId, g as isRequestFailureEcho, h as isFaviconUrl, i as listRuns, l as RUN_ID_PATTERN, m as createRequestFinding, n as closeRun, o as saveRunEvent, p as createConsoleFinding, r as createRun, s as runEventSchema, t as closeLeftOpenRuns, u as createStepId } from "./runs-store-Bd_ITPFj.mjs";
+import { parseArgs } from "node:util";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { join } from "node:path";
+import { hc } from "hono/client";
+import { glob, mkdir, open, readFile, rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { serve, upgradeWebSocket } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { WebSocketServer } from "ws";
+import { chromium, errors, firefox, webkit } from "playwright";
+import { parse } from "yaml";
+import { zValidator } from "@hono/zod-validator";
+// src/cli/cli-flags.ts
+const FLAG_TYPES = {
+	json: { type: "boolean" },
+	help: { type: "boolean" },
+	foreground: { type: "boolean" },
+	touch: { type: "boolean" },
+	yes: { type: "boolean" },
+	port: { type: "string" },
+	device: { type: "string" },
+	devices: { type: "string" },
+	before: { type: "string" },
+	"max-routes": { type: "string" },
+	url: { type: "string" },
+	role: { type: "string" },
+	name: { type: "string" },
+	with: { type: "string" },
+	to: { type: "string" },
+	text: { type: "string" },
+	flows: { type: "string" },
+	parallel: { type: "string" },
+	agent: { type: "string" },
+	width: { type: "string" },
+	height: { type: "string" },
+	"pixel-ratio": { type: "string" }
+};
+const parseCommandLine = (commandLineWords) => parseArgs({
+	args: commandLineWords,
+	options: FLAG_TYPES,
+	allowPositionals: true,
+	strict: true
+});
+const readCommandLine = (commandLineWords) => {
+	try {
+		const { positionals, values } = parseCommandLine(commandLineWords);
+		return {
+			kind: "read",
+			commandWords: positionals,
+			flags: values
+		};
+	} catch (error) {
+		const [reason] = (error instanceof Error ? error.message : "unreadable flags").split(". ");
+		return {
+			kind: "unreadable",
+			message: `bad usage · ${reason} · run everyscreen --help`
+		};
+	}
+};
+// src/cli/cli-help-pages.ts
+const CLI_COMMAND_NAMES = [
+	"start",
+	"stop",
+	"status",
+	"open",
+	"tap",
+	"fill",
+	"scroll",
+	"check",
+	"shot",
+	"expect",
+	"sweep",
+	"devices list",
+	"devices add",
+	"devices remove",
+	"run",
+	"skill install"
+];
+const DEVICE_FLAG_HELP = {
+	flag: "--device <id>",
+	description: "Run on one device. Default: every device"
+};
+const YES_FLAG_HELP = {
+	flag: "--yes",
+	description: "Go ahead without asking. Needed when there is no terminal"
+};
+const COMMAND_HELPS = {
+	start: {
+		summary: "Start the hub and one browser per device, in the background",
+		usage: "everyscreen start [--port <number>] [--foreground]",
+		flagHelps: [{
+			flag: "--port <number>",
+			description: "Port for the hub. Default: 4100"
+		}, {
+			flag: "--foreground",
+			description: "Keep the hub in this terminal instead of the background"
+		}]
+	},
+	stop: {
+		summary: "Stop the hub and close every device browser",
+		usage: "everyscreen stop",
+		flagHelps: []
+	},
+	status: {
+		summary: "Show whether the hub is running and how many devices it has",
+		usage: "everyscreen status",
+		flagHelps: []
+	},
+	open: {
+		summary: "Open a url on every device",
+		usage: "everyscreen open --url <url> [--device <id>]",
+		flagHelps: [{
+			flag: "--url <url>",
+			description: "The page to open"
+		}, DEVICE_FLAG_HELP]
+	},
+	tap: {
+		summary: "Tap an element on every device",
+		usage: "everyscreen tap --role <role> --name <name> [--device <id>]",
+		flagHelps: [
+			{
+				flag: "--role <role>",
+				description: "Aria role: button, link, textbox, checkbox, tab..."
+			},
+			{
+				flag: "--name <name>",
+				description: "Accessible name of the element"
+			},
+			DEVICE_FLAG_HELP
+		]
+	},
+	fill: {
+		summary: "Type into a field on every device",
+		usage: "everyscreen fill --role <role> --name <name> --with <text> [--device <id>]",
+		flagHelps: [
+			{
+				flag: "--role <role>",
+				description: "Aria role of the field: textbox, searchbox, combobox..."
+			},
+			{
+				flag: "--name <name>",
+				description: "Accessible name of the field"
+			},
+			{
+				flag: "--with <text>",
+				description: "What to type"
+			},
+			DEVICE_FLAG_HELP
+		]
+	},
+	scroll: {
+		summary: "Scroll to the top or the bottom of the page",
+		usage: "everyscreen scroll --to top|bottom [--device <id>]",
+		flagHelps: [{
+			flag: "--to top|bottom",
+			description: "Where to scroll"
+		}, DEVICE_FLAG_HELP]
+	},
+	check: {
+		summary: "Run the six checks on the current page",
+		usage: "everyscreen check [--device <id>]",
+		flagHelps: [DEVICE_FLAG_HELP]
+	},
+	shot: {
+		summary: "Save a screenshot of every device",
+		usage: "everyscreen shot [--device <id>]",
+		flagHelps: [DEVICE_FLAG_HELP]
+	},
+	expect: {
+		summary: "Check that some text shows on every device",
+		usage: "everyscreen expect --text <text> [--device <id>]",
+		flagHelps: [{
+			flag: "--text <text>",
+			description: "The text that must show"
+		}, DEVICE_FLAG_HELP]
+	},
+	sweep: {
+		summary: "Visit every route of your app and save a shot on every device",
+		usage: "everyscreen sweep --url <url> [--devices <id,id,...>|all] [--max-routes <number>] [--before <flow.yaml>]",
+		flagHelps: [
+			{
+				flag: "--url <url>",
+				description: "The start page of your app"
+			},
+			{
+				flag: "--devices <id,id,...>|all",
+				description: "Which devices to sweep. all adds every catalog device. Default: the grid"
+			},
+			{
+				flag: "--max-routes <number>",
+				description: "Most routes to visit, up to 500. Default: 50"
+			},
+			{
+				flag: "--before <flow.yaml>",
+				description: "Run this flow first on each device, for example a login. Default: none"
+			}
+		]
+	},
+	"devices list": {
+		summary: "List the devices in the grid",
+		usage: "everyscreen devices list",
+		flagHelps: []
+	},
+	"devices add": {
+		summary: "Add a custom device to everyscreen.yaml and start it on the running hub",
+		usage: "everyscreen devices add --name <name> --width <px> --height <px> [--pixel-ratio <number>] [--touch]",
+		flagHelps: [
+			{
+				flag: "--name <name>",
+				description: "Device name. Its id is made from it"
+			},
+			{
+				flag: "--width <px>",
+				description: "Viewport width"
+			},
+			{
+				flag: "--height <px>",
+				description: "Viewport height"
+			},
+			{
+				flag: "--pixel-ratio <number>",
+				description: "Pixel ratio, 1 to 4. Default: 1"
+			},
+			{
+				flag: "--touch",
+				description: "The device has a touch screen"
+			}
+		]
+	},
+	"devices remove": {
+		summary: "Remove a custom device from everyscreen.yaml and stop it on the running hub",
+		usage: "everyscreen devices remove --device <id> [--yes]",
+		flagHelps: [{
+			flag: "--device <id>",
+			description: "The custom device to remove"
+		}, YES_FLAG_HELP]
+	},
+	run: {
+		summary: "Run YAML flows on the devices they name",
+		usage: "everyscreen run [--flows <glob>] [--parallel <number>]",
+		flagHelps: [{
+			flag: "--flows <glob>",
+			description: "Which flow files to run. Default: flows/*.yaml"
+		}, {
+			flag: "--parallel <number>",
+			description: "Flows to run at the same time. Default: 1"
+		}]
+	},
+	"skill install": {
+		summary: "Install the Everyscreen skill for a coding agent",
+		usage: "everyscreen skill install [--agent claude|codex|cursor] [--yes]",
+		flagHelps: [{
+			flag: "--agent <name>",
+			description: "Which agent reads it. Default: claude"
+		}, YES_FLAG_HELP]
+	}
+};
+// src/commands/commands-schema.ts
+const ARIA_ROLES = [
+	"button",
+	"checkbox",
+	"combobox",
+	"dialog",
+	"heading",
+	"img",
+	"link",
+	"listitem",
+	"menuitem",
+	"option",
+	"radio",
+	"searchbox",
+	"slider",
+	"spinbutton",
+	"switch",
+	"tab",
+	"textbox"
+];
+const DEFAULT_MAX_ROUTES = 50;
+const MAX_SWEEP_ROUTES = 500;
+const URL_MESSAGE = "needs --url <web address, like https://example.com>";
+const ROLE_MESSAGE = `needs --role <one of ${ARIA_ROLES.join(", ")}>`;
+const NAME_MESSAGE = "needs --name <text>";
+const MAX_ROUTES_MINIMUM_MESSAGE = "--max-routes must be a whole number of 1 or more";
+const DEVICES_MESSAGE = "--devices must be all or a list of device ids, like iphone-17,pixel-10";
+const deviceIdsSchema = z.array(z.string()).nullable();
+const openCommandSchema = z.object({
+	commandName: z.literal("open"),
+	url: z.url({ error: URL_MESSAGE }),
+	deviceIds: deviceIdsSchema
+});
+const tapCommandSchema = z.object({
+	commandName: z.literal("tap"),
+	role: z.enum(ARIA_ROLES, { error: ROLE_MESSAGE }),
+	name: z.string({ error: NAME_MESSAGE }),
+	deviceIds: deviceIdsSchema
+});
+const fillCommandSchema = z.object({
+	commandName: z.literal("fill"),
+	role: z.enum(ARIA_ROLES, { error: ROLE_MESSAGE }),
+	name: z.string({ error: NAME_MESSAGE }),
+	with: z.string({ error: "needs --with <text>" }),
+	deviceIds: deviceIdsSchema
+});
+const scrollCommandSchema = z.object({
+	commandName: z.literal("scroll"),
+	to: z.enum(["top", "bottom"], { error: "needs --to top or bottom" }),
+	deviceIds: deviceIdsSchema
+});
+const checkCommandSchema = z.object({
+	commandName: z.literal("check"),
+	deviceIds: deviceIdsSchema
+});
+const shotCommandSchema = z.object({
+	commandName: z.literal("shot"),
+	deviceIds: deviceIdsSchema
+});
+const expectCommandSchema = z.object({
+	commandName: z.literal("expect"),
+	text: z.string({ error: "needs --text <text>" }),
+	deviceIds: deviceIdsSchema
+});
+const beforeStepSchema = z.discriminatedUnion("commandName", [
+	openCommandSchema,
+	tapCommandSchema,
+	fillCommandSchema,
+	scrollCommandSchema,
+	checkCommandSchema,
+	shotCommandSchema,
+	expectCommandSchema
+]);
+const sweepCommandSchema = z.object({
+	commandName: z.literal("sweep"),
+	url: z.url({ error: URL_MESSAGE }),
+	deviceIds: z.union([z.literal("all"), z.array(z.string().min(1, { error: DEVICES_MESSAGE })).min(1, { error: DEVICES_MESSAGE })], { error: DEVICES_MESSAGE }).nullable().default(null),
+	maxRoutes: z.number({ error: MAX_ROUTES_MINIMUM_MESSAGE }).int({ error: MAX_ROUTES_MINIMUM_MESSAGE }).positive({ error: MAX_ROUTES_MINIMUM_MESSAGE }).max(MAX_SWEEP_ROUTES, { error: `--max-routes must be ${MAX_SWEEP_ROUTES} or less` }).default(DEFAULT_MAX_ROUTES),
+	beforeSteps: z.array(beforeStepSchema).nullable().default(null)
+});
+const hubCommandSchema = z.discriminatedUnion("commandName", [
+	openCommandSchema,
+	sweepCommandSchema,
+	tapCommandSchema,
+	fillCommandSchema,
+	scrollCommandSchema,
+	checkCommandSchema,
+	shotCommandSchema,
+	expectCommandSchema
+]);
+// src/skill/skill-agents.ts
+const SKILL_AGENTS = [
+	"claude",
+	"codex",
+	"cursor"
+];
+// src/cli/cli-logic.ts
+const DEFAULT_FLOWS_GLOB = "flows/*.yaml";
+const DEFAULT_PARALLEL = 1;
+const MAX_PORT = 65535;
+const COLUMN_GAP = "  ";
+const PRODUCT_LINE = "Run your web app on many device sizes at once.";
+const HUB_DOWN_LINE = "hub is not running · run npx everyscreen start";
+const PORT_MESSAGE = `--port must be a whole number from 0 to ${MAX_PORT}`;
+const FLOWS_MESSAGE = "--flows must be a file pattern, like flows/*.yaml";
+const PARALLEL_MESSAGE = "--parallel must be a whole number of 1 or more";
+const BEFORE_MESSAGE = "--before needs a flow file path";
+const startFlagsSchema = z.object({
+	port: z.number({ error: PORT_MESSAGE }).int({ error: PORT_MESSAGE }).min(0, { error: PORT_MESSAGE }).max(MAX_PORT, { error: PORT_MESSAGE }).optional(),
+	foreground: z.boolean().default(false)
+});
+const runFlagsSchema = z.object({
+	flows: z.string({ error: FLOWS_MESSAGE }).min(1, { error: FLOWS_MESSAGE }).default(DEFAULT_FLOWS_GLOB),
+	parallel: z.number({ error: PARALLEL_MESSAGE }).int({ error: PARALLEL_MESSAGE }).min(1, { error: PARALLEL_MESSAGE }).default(DEFAULT_PARALLEL)
+});
+const sweepFlagsSchema = z.object({
+	url: sweepCommandSchema.shape.url,
+	devices: sweepCommandSchema.shape.deviceIds,
+	"max-routes": sweepCommandSchema.shape.maxRoutes,
+	before: z.string({ error: BEFORE_MESSAGE }).min(1, { error: BEFORE_MESSAGE }).nullable().default(null)
+});
+const skillFlagsSchema = z.object({ agent: z.enum(SKILL_AGENTS, { error: `--agent must be one of ${SKILL_AGENTS.join(", ")}` }).default("claude") });
+const removeDeviceFlagsSchema = z.object({ device: z.string({ error: "needs --device <device id>" }) });
+const COMMON_FLAG_HELPS = [{
+	flag: "--json",
+	description: "Print one JSON object"
+}, {
+	flag: "--help",
+	description: "Show this help"
+}];
+const createReply = (status, line) => ({
+	status,
+	line,
+	runId: null,
+	failures: []
+});
+const createHubDownReply = () => createReply("failed", HUB_DOWN_LINE);
+const createReadyLine = (hubUrl, deviceCount) => `hub ready at ${hubUrl} · ${deviceCount} devices`;
+const createRunningLine = (hubUrl, deviceCount) => `hub running at ${hubUrl} · ${deviceCount} devices`;
+const createDeviceListLine = (deviceIds) => `${deviceIds.length} devices · ${deviceIds.join(", ")}`;
+const createBadUsageLine = (detail) => `bad usage · ${detail}`;
+const pickBadUsageDetail = (error) => {
+	return error instanceof HTTPException && error.status === 400 ? error.message : null;
+};
+const isPortConflict = (requestedPort, runningPort) => requestedPort !== null && requestedPort !== runningPort;
+const createPortConflictReply = (hubUrl) => createReply("failed", `hub already running at ${hubUrl} · stop it first`);
+const canWriteFinalReply = (cliRequest, isJsonWanted, isTerminal) => {
+	return !(cliRequest.kind === "start" && cliRequest.isForeground && (isJsonWanted || !isTerminal));
+};
+const createPrintedReply = (commandReply, isJsonWanted, isTerminal) => {
+	if (isJsonWanted || !isTerminal) return JSON.stringify(commandReply);
+	const failureLines = commandReply.failures.map(({ deviceId, message, durationMs }) => `${deviceId}  failed  ${message}  ${durationMs} ms`);
+	return [commandReply.line, ...failureLines].join("\n");
+};
+const createHelpLines = (helpLines) => {
+	const flagLengths = helpLines.map(({ flag }) => flag.length);
+	const widestName = Math.max(...flagLengths);
+	return helpLines.map(({ flag, description }) => `  ${flag.padEnd(widestName)}${COLUMN_GAP}${description}`);
+};
+const createHelpPage = (cliCommandName) => {
+	if (cliCommandName === null) {
+		const commandHelps = CLI_COMMAND_NAMES.map((commandName) => ({
+			flag: commandName,
+			description: COMMAND_HELPS[commandName].summary
+		}));
+		const commandLines = createHelpLines(commandHelps);
+		return [
+			`everyscreen · ${PRODUCT_LINE}`,
+			"",
+			"Usage: everyscreen <command> [flags]",
+			"",
+			"Commands:",
+			...commandLines,
+			"",
+			"Every command takes --json (print one JSON object) and --help.",
+			"Run everyscreen <command> --help for the flags of one command."
+		].join("\n");
+	}
+	const commandHelp = COMMAND_HELPS[cliCommandName];
+	const flagLines = createHelpLines([...commandHelp.flagHelps, ...COMMON_FLAG_HELPS]);
+	return [
+		`everyscreen ${cliCommandName} · ${commandHelp.summary}`,
+		"",
+		`Usage: ${commandHelp.usage}`,
+		"",
+		"Flags:",
+		...flagLines
+	].join("\n");
+};
+const pickCommandName = (commandWords) => {
+	const joinedWords = commandWords.join(" ");
+	return CLI_COMMAND_NAMES.find((commandName) => commandName === joinedWords) ?? null;
+};
+const readNumberFlag = (flagWord) => {
+	if (flagWord === void 0) return void 0;
+	if (flagWord === "") return NaN;
+	return Number(flagWord);
+};
+const readDevicesFlag = (flagWord) => {
+	if (flagWord === void 0) return void 0;
+	if (flagWord === "all") return "all";
+	return flagWord.split(",").map((deviceId) => deviceId.trim());
+};
+const createBadUsage = (commandName, issue) => ({
+	kind: "bad-usage",
+	message: createBadUsageLine(`${commandName} ${issue.message}`)
+});
+const createReadyCheck = (cliRequest) => ({
+	kind: "ready",
+	cliRequest
+});
+const checkHubCommandFlags = (commandName, flags) => {
+	const isDeviceMissing = flags.device === void 0;
+	const hubCommandCandidate = {
+		commandName,
+		url: flags.url,
+		role: flags.role,
+		name: flags.name,
+		with: flags.with,
+		to: flags.to,
+		text: flags.text,
+		deviceIds: isDeviceMissing ? null : [flags.device]
+	};
+	const hubCommandCheck = hubCommandSchema.safeParse(hubCommandCandidate);
+	if (hubCommandCheck.success) return createReadyCheck({
+		kind: "send-command",
+		hubCommand: hubCommandCheck.data
+	});
+	return createBadUsage(commandName, hubCommandCheck.error.issues[0]);
+};
+const checkStartFlags = (flags) => {
+	const startCheck = startFlagsSchema.safeParse({
+		port: readNumberFlag(flags.port),
+		foreground: flags.foreground
+	});
+	if (startCheck.success) return createReadyCheck({
+		kind: "start",
+		port: startCheck.data.port ?? null,
+		isForeground: startCheck.data.foreground
+	});
+	return createBadUsage("start", startCheck.error.issues[0]);
+};
+const checkAddDeviceFlags = (flags) => {
+	const customDeviceCheck = customDeviceSchema.safeParse({
+		name: flags.name,
+		width: readNumberFlag(flags.width),
+		height: readNumberFlag(flags.height),
+		pixelRatio: readNumberFlag(flags["pixel-ratio"]),
+		hasTouch: flags.touch
+	});
+	if (customDeviceCheck.success) return createReadyCheck({
+		kind: "add-device",
+		customDevice: customDeviceCheck.data
+	});
+	return createBadUsage("devices add", customDeviceCheck.error.issues[0]);
+};
+const checkRemoveDeviceFlags = (flags, isConfirmed) => {
+	const removeCheck = removeDeviceFlagsSchema.safeParse(flags);
+	if (!removeCheck.success) return createBadUsage("devices remove", removeCheck.error.issues[0]);
+	if (!isConfirmed) return {
+		kind: "bad-usage",
+		message: createBadUsageLine("devices remove needs --yes when it does not run in a terminal")
+	};
+	return createReadyCheck({
+		kind: "remove-device",
+		deviceId: removeCheck.data.device
+	});
+};
+const checkRunFlowsFlags = (flags) => {
+	const runCheck = runFlagsSchema.safeParse({
+		flows: flags.flows,
+		parallel: readNumberFlag(flags.parallel)
+	});
+	if (runCheck.success) return createReadyCheck({
+		kind: "run-flows",
+		flowsGlob: runCheck.data.flows,
+		parallel: runCheck.data.parallel
+	});
+	return createBadUsage("run", runCheck.error.issues[0]);
+};
+const checkSweepFlags = (flags) => {
+	const sweepCheck = sweepFlagsSchema.safeParse({
+		url: flags.url,
+		devices: readDevicesFlag(flags.devices),
+		"max-routes": readNumberFlag(flags["max-routes"]),
+		before: flags.before
+	});
+	if (sweepCheck.success) {
+		const sweepFlags = sweepCheck.data;
+		return createReadyCheck({
+			kind: "run-sweep",
+			sweepCommand: {
+				commandName: "sweep",
+				url: sweepFlags.url,
+				deviceIds: sweepFlags.devices,
+				maxRoutes: sweepFlags["max-routes"],
+				beforeSteps: null
+			},
+			beforeFlowPath: sweepFlags.before
+		});
+	}
+	return createBadUsage("sweep", sweepCheck.error.issues[0]);
+};
+const checkInstallSkillFlags = (flags, isConfirmed) => {
+	const skillCheck = skillFlagsSchema.safeParse(flags);
+	if (skillCheck.success) return createReadyCheck({
+		kind: "install-skill",
+		agent: skillCheck.data.agent,
+		isConfirmed
+	});
+	return createBadUsage("skill install", skillCheck.error.issues[0]);
+};
+const checkRequestFlags = (commandName, flags, isConfirmed) => {
+	switch (commandName) {
+		case "start": return checkStartFlags(flags);
+		case "stop": return createReadyCheck({ kind: "stop" });
+		case "status": return createReadyCheck({ kind: "status" });
+		case "devices list": return createReadyCheck({ kind: "list-devices" });
+		case "devices add": return checkAddDeviceFlags(flags);
+		case "devices remove": return checkRemoveDeviceFlags(flags, isConfirmed);
+		case "run": return checkRunFlowsFlags(flags);
+		case "sweep": return checkSweepFlags(flags);
+		case "skill install": return checkInstallSkillFlags(flags, isConfirmed);
+		case "open":
+		case "tap":
+		case "fill":
+		case "scroll":
+		case "check":
+		case "shot":
+		case "expect": return checkHubCommandFlags(commandName, flags);
+	}
+};
+const planCli = (commandWords, flags, isTerminal) => {
+	const commandName = pickCommandName(commandWords);
+	const isHelpWanted = flags.help === true;
+	const isNothingTyped = commandWords.length === 0;
+	const isCommandUnknown = commandName === null;
+	if (isNothingTyped || isCommandUnknown && isHelpWanted) return {
+		kind: "show-help",
+		helpPage: createHelpPage(null)
+	};
+	if (isCommandUnknown) return {
+		kind: "bad-usage",
+		message: `bad usage · unknown command "${commandWords.join(" ")}" · run everyscreen --help`
+	};
+	if (isHelpWanted) return {
+		kind: "show-help",
+		helpPage: createHelpPage(commandName)
+	};
+	const isConfirmed = flags.yes === true || isTerminal;
+	const requestCheck = checkRequestFlags(commandName, flags, isConfirmed);
+	if (requestCheck.kind === "bad-usage") return requestCheck;
+	return {
+		kind: "run",
+		cliRequest: requestCheck.cliRequest
+	};
+};
+// src/cli/cli-reply.ts
+const writeReply = (commandReply, isJsonWanted) => {
+	const isTerminal = process.stdout.isTTY === true;
+	const printedReply = createPrintedReply(commandReply, isJsonWanted, isTerminal);
+	process.stdout.write(`${printedReply}\n`);
+};
+// src/cli/hub-client.ts
+const ANSWER_TIMEOUT_MS = 3e3;
+const LOST_CONNECTION_CODES = ["ECONNREFUSED", "ECONNRESET"];
+const problemSchema = z.object({ detail: z.string() });
+const createHubClient = (hubUrl) => hc(hubUrl);
+const createHubUrl = (hubFile) => `http://${HUB_HOST}:${hubFile.port}`;
+const countDevices = (hubFile) => Object.keys(hubFile.devices).length;
+const readHubFile = async (rootFolder) => {
+	const hubFilePath = join(rootFolder, HUB_FILE_PATH);
+	const serializedHubFile = await readStoredFile(hubFilePath);
+	if (serializedHubFile === null) return null;
+	const hubFileDocument = JSON.parse(serializedHubFile);
+	return hubFileSchema.parse(hubFileDocument);
+};
+const isConnectionLost = (error) => {
+	if (!(error instanceof TypeError)) return false;
+	const lostCause = error.cause;
+	if (!(lostCause instanceof Error && "code" in lostCause)) return false;
+	const lostCode = String(lostCause.code);
+	return LOST_CONNECTION_CODES.includes(lostCode);
+};
+const isAnswerTimeout = (error) => error instanceof DOMException && error.name === "TimeoutError";
+const readProblemReply = async (problemReply) => {
+	const problemDocument = await problemReply.json();
+	const problem = problemSchema.parse(problemDocument);
+	if (problemReply.status === 400) throw new HTTPException(400, { message: problem.detail });
+	return createReply("failed", problem.detail);
+};
+const isHubAnswering = async (hubFile) => {
+	const hubUrl = createHubUrl(hubFile);
+	const hubClient = createHubClient(hubUrl);
+	try {
+		await hubClient.api.devices.$get({}, { init: { signal: AbortSignal.timeout(ANSWER_TIMEOUT_MS) } });
+		return true;
+	} catch (error) {
+		if (isConnectionLost(error) || isAnswerTimeout(error)) return false;
+		throw error;
+	}
+};
+const callHub = async (rootFolder, askHubClient) => {
+	const hubFile = await readHubFile(rootFolder);
+	if (hubFile === null) return createHubDownReply();
+	const hubUrl = createHubUrl(hubFile);
+	const hubClient = createHubClient(hubUrl);
+	try {
+		return await askHubClient(hubClient, hubUrl);
+	} catch (error) {
+		if (isConnectionLost(error)) return createHubDownReply();
+		throw error;
+	}
+};
+const sendHubCommand = (rootFolder, hubCommand) => callHub(rootFolder, async (hubClient) => {
+	const commandsReply = await hubClient.api.commands.$post({ json: hubCommand });
+	if (!commandsReply.ok) return readProblemReply(commandsReply);
+	return commandsReply.json();
+});
+// src/live/screen-priority-logic.ts
+const pickScreenPhase = (testStatuses) => {
+	return testStatuses.includes("running") ? "following-hub" : "keeping-test-screen";
+};
+const isScreenAccepted = (screenSource, screenPhase) => {
+	return screenSource === "test-run" || screenPhase === "following-hub";
+};
+// src/live/live-feed.ts
+const listeners = /* @__PURE__ */ new Set();
+const lastScreens = /* @__PURE__ */ new Map();
+const lastTests = /* @__PURE__ */ new Map();
+const lastSteps = /* @__PURE__ */ new Map();
+const screenPhases = /* @__PURE__ */ new Map();
+let recentCommands = [];
+const lastRunTotals = { runTotals: null };
+const subscribe = (listener) => {
+	listeners.add(listener);
+	for (const lastScreen of lastScreens.values()) listener(lastScreen);
+	const { runTotals } = lastRunTotals;
+	if (runTotals !== null) listener({
+		kind: "run-totals",
+		...runTotals
+	});
+	for (const [testId, testEvent] of lastTests) {
+		listener({
+			kind: "test",
+			...testEvent
+		});
+		const testSteps = lastSteps.get(testId) ?? [];
+		for (const stepEvent of testSteps) listener({
+			kind: "step",
+			...stepEvent
+		});
+	}
+	for (const recentCommand of recentCommands) listener(recentCommand);
+	return () => listeners.delete(listener);
+};
+const rememberTest = (testEvent) => {
+	if (testEvent.status === "running") lastSteps.delete(testEvent.testId);
+	lastTests.delete(testEvent.testId);
+	lastTests.set(testEvent.testId, testEvent);
+};
+const rememberStep = (stepEvent) => {
+	const otherSteps = (lastSteps.get(stepEvent.testId) ?? []).filter(({ stepIndex }) => stepIndex !== stepEvent.stepIndex);
+	lastSteps.set(stepEvent.testId, [...otherSteps, stepEvent]);
+};
+const rememberScreenPhase = (deviceId) => {
+	const deviceStatuses = [...lastTests.values()].filter((testEvent) => testEvent.deviceId === deviceId).map(({ status }) => status);
+	screenPhases.set(deviceId, pickScreenPhase(deviceStatuses));
+};
+const forgetAllTests = () => {
+	lastTests.clear();
+	lastSteps.clear();
+};
+const broadcast = (message, screenSource = "hub") => {
+	switch (message.kind) {
+		case "screen": {
+			const screenPhase = screenPhases.get(message.deviceId) ?? "following-hub";
+			if (!isScreenAccepted(screenSource, screenPhase)) return;
+			lastScreens.set(message.deviceId, message);
+			break;
+		}
+		case "test":
+			rememberTest(message);
+			rememberScreenPhase(message.deviceId);
+			break;
+		case "step":
+			rememberStep(message);
+			break;
+		case "run-totals":
+			if (message.phase === "start") {
+				forgetAllTests();
+				screenPhases.clear();
+			}
+			lastRunTotals.runTotals = message;
+			break;
+		case "command": recentCommands = [...recentCommands, message].slice(-8);
+	}
+	for (const listener of listeners) listener(message);
+};
+const forgetDeviceScreen = (deviceId) => {
+	lastScreens.delete(deviceId);
+	screenPhases.delete(deviceId);
+};
+const releaseDeviceScreen = (deviceId) => {
+	screenPhases.delete(deviceId);
+};
+const listRunningTests = () => [...lastTests.values()].filter(({ status }) => status === "running");
+const readRunTotals = () => lastRunTotals.runTotals;
+const forgetTests = (deviceIds) => {
+	const forgottenTestIds = [...lastTests.values()].filter(({ deviceId }) => deviceIds.includes(deviceId)).map(({ testId }) => testId);
+	for (const testId of forgottenTestIds) {
+		lastTests.delete(testId);
+		lastSteps.delete(testId);
+	}
+	lastRunTotals.runTotals = null;
+};
+// src/checks/page-watch.ts
+const HTTP_ERROR_STATUS = 400;
+const watchPage = async (page, deviceId) => {
+	const sentFindingKeys = /* @__PURE__ */ new Set();
+	const sendFinding = (finding) => {
+		const findingKey = `${finding.kind}|${finding.message}`;
+		if (sentFindingKeys.has(findingKey)) return;
+		sentFindingKeys.add(findingKey);
+		broadcast({
+			kind: "finding",
+			finding
+		});
+	};
+	const onConsole = (consoleMessage) => {
+		const consoleLine = consoleMessage.text();
+		if (!(consoleMessage.type() === "error" && !isRequestFailureEcho(consoleLine))) return;
+		sendFinding(createConsoleFinding(deviceId, consoleLine));
+	};
+	const onPageError = (error) => {
+		sendFinding(createConsoleFinding(deviceId, error.message));
+	};
+	const onRequestFailed = (request) => {
+		const failureReason = request.failure()?.errorText ?? null;
+		sendFinding(createRequestFinding(deviceId, request.url(), failureReason));
+	};
+	const onResponse = (httpResponse) => {
+		const isHttpError = httpResponse.status() >= HTTP_ERROR_STATUS;
+		const isFavicon = isFaviconUrl(httpResponse.url());
+		if (!isHttpError || isFavicon) return;
+		const failureReason = String(httpResponse.status());
+		const requestUrl = httpResponse.url();
+		sendFinding(createRequestFinding(deviceId, requestUrl, failureReason));
+	};
+	const onNavigated = (frame) => {
+		if (frame === page.mainFrame()) sentFindingKeys.clear();
+	};
+	page.on("console", onConsole);
+	page.on("pageerror", onPageError);
+	page.on("requestfailed", onRequestFailed);
+	page.on("response", onResponse);
+	page.on("framenavigated", onNavigated);
+	return async () => {
+		page.off("console", onConsole);
+		page.off("pageerror", onPageError);
+		page.off("requestfailed", onRequestFailed);
+		page.off("response", onResponse);
+		page.off("framenavigated", onNavigated);
+	};
+};
+// src/devices/device-emulation.ts
+const emulateDevice = async (page, devicePreset) => {
+	const { deviceScaleFactor, isMobile, hasTouch, userAgent } = devicePreset.use;
+	const viewport = pickDeviceViewport(devicePreset);
+	const screen = pickDeviceScreen(devicePreset);
+	const { bottom, left, right } = devicePreset.safeAreaInsets;
+	const wholeInsets = {
+		top: 0,
+		bottom: Math.round(bottom),
+		left: Math.round(left),
+		right: Math.round(right)
+	};
+	const cdpSession = await page.context().newCDPSession(page);
+	await cdpSession.send("Emulation.setDeviceMetricsOverride", {
+		width: viewport.width,
+		height: viewport.height,
+		screenWidth: screen.width,
+		screenHeight: screen.height,
+		deviceScaleFactor: deviceScaleFactor ?? 1,
+		mobile: isMobile ?? false
+	});
+	await cdpSession.send("Emulation.setTouchEmulationEnabled", { enabled: hasTouch ?? false });
+	await cdpSession.send("Emulation.setSafeAreaInsetsOverride", { insets: wholeInsets });
+	if (userAgent !== void 0) await cdpSession.send("Emulation.setUserAgentOverride", { userAgent });
+};
+// src/estimates/estimates-logic.ts
+const FULL_CPU_PERCENT = 100;
+const PERCENT_SCALE = 100;
+const BYTES_PER_MEGABYTE = 1e6;
+const MILLISECONDS_PER_SECOND = 1e3;
+const createIdleDeviceLoad = () => ({
+	label: "est.",
+	fps: 0,
+	cpuPercent: 0,
+	memoryMegabytes: 0,
+	layoutShift: 0
+});
+const estimateDeviceLoad = (samples) => {
+	const firstSample = samples.at(0);
+	const lastSample = samples.at(-1);
+	if (firstSample === void 0 || lastSample === void 0 || firstSample === lastSample) return createIdleDeviceLoad();
+	const wallSeconds = (lastSample.takenAt - firstSample.takenAt) / MILLISECONDS_PER_SECOND;
+	if (wallSeconds <= 0) return createIdleDeviceLoad();
+	const fps = (lastSample.frames - firstSample.frames) / wallSeconds;
+	const busyPercent = (lastSample.taskSeconds - firstSample.taskSeconds) / wallSeconds * PERCENT_SCALE;
+	return {
+		label: "est.",
+		fps,
+		cpuPercent: Math.min(FULL_CPU_PERCENT, busyPercent),
+		memoryMegabytes: lastSample.heapBytes / BYTES_PER_MEGABYTE,
+		layoutShift: lastSample.layoutShift
+	};
+};
+const pickSampleWindow = (recentSamples, newSample, windowSize) => {
+	const lastSample = recentSamples.at(-1);
+	if (lastSample !== void 0 && newSample.frames < lastSample.frames) return [newSample];
+	return [...recentSamples.slice(-(windowSize - 1)), newSample];
+};
+// src/estimates/estimates-sampler.ts
+const SAMPLE_INTERVAL_MS = 1e3;
+const SAMPLE_WINDOW = 5;
+const COUNTERS_KEY = "everyscreenCounters";
+const pageCountersSchema = z.object({
+	frames: z.number(),
+	layoutShift: z.number()
+});
+const counterReadingSchema = z.array(z.object({
+	name: z.string(),
+	value: z.number()
+}));
+const watchFrames = (countersKey) => {
+	const isLayoutShift = (performanceEntry) => performanceEntry.entryType === "layout-shift";
+	if (countersKey in window) return;
+	const counters = {
+		frames: 0,
+		layoutShift: 0
+	};
+	const countFrame = () => {
+		counters.frames += 1;
+		requestAnimationFrame(countFrame);
+	};
+	requestAnimationFrame(countFrame);
+	new PerformanceObserver((entryList) => {
+		for (const layoutShiftEntry of entryList.getEntries().filter(isLayoutShift)) if (!layoutShiftEntry.hadRecentInput) counters.layoutShift += layoutShiftEntry.value;
+	}).observe({
+		type: "layout-shift",
+		buffered: true
+	});
+	Object.assign(window, { [countersKey]: counters });
+};
+const findCounterReading = (counterReadings, counterName) => {
+	const counterReading = counterReadings.find((candidate) => candidate.name === counterName);
+	if (counterReading === void 0) throw new Error(`Chromium did not report the ${counterName} counter`);
+	return counterReading.value;
+};
+const readSample = async (cdpSession, page) => {
+	const performanceReply = await cdpSession.send("Performance.getMetrics");
+	const counterReadings = counterReadingSchema.parse(performanceReply.metrics);
+	const pageCountersReply = await page.evaluate((countersKey) => Reflect.get(window, countersKey), COUNTERS_KEY);
+	const pageCounters = pageCountersSchema.parse(pageCountersReply);
+	return {
+		takenAt: Date.now(),
+		taskSeconds: findCounterReading(counterReadings, "TaskDuration"),
+		layoutSeconds: findCounterReading(counterReadings, "LayoutDuration"),
+		heapBytes: findCounterReading(counterReadings, "JSHeapUsedSize"),
+		frames: pageCounters.frames,
+		layoutShift: pageCounters.layoutShift
+	};
+};
+const waitForNextSample = async (signal) => {
+	try {
+		await setTimeout$1(SAMPLE_INTERVAL_MS, null, { signal });
+	} catch (error) {
+		if (signal.aborted) return;
+		throw error;
+	}
+};
+const sampleUntilStopped = async (cdpSession, page, deviceId, signal) => {
+	const sampleWindow = { samples: [] };
+	while (!signal.aborted) {
+		await waitForNextSample(signal);
+		if (signal.aborted) break;
+		try {
+			const sample = await readSample(cdpSession, page);
+			sampleWindow.samples = pickSampleWindow(sampleWindow.samples, sample, SAMPLE_WINDOW);
+			const deviceLoad = estimateDeviceLoad(sampleWindow.samples);
+			broadcast({
+				kind: "estimate",
+				deviceId,
+				deviceLoad
+			});
+		} catch (error) {
+			if (!(page.isClosed() || signal.aborted)) console.error({
+				deviceId,
+				error
+			});
+		}
+	}
+};
+const startSampling = async (page, deviceId) => {
+	const cdpSession = await page.context().newCDPSession(page);
+	await cdpSession.send("Performance.enable");
+	await page.addInitScript(watchFrames, COUNTERS_KEY);
+	await page.evaluate(watchFrames, COUNTERS_KEY);
+	const abortController = new AbortController();
+	const samplingLoop = sampleUntilStopped(cdpSession, page, deviceId, abortController.signal);
+	const stopOnPageClose = () => abortController.abort();
+	page.on("close", stopOnPageClose);
+	return async () => {
+		abortController.abort();
+		page.off("close", stopOnPageClose);
+		await samplingLoop;
+		if (!page.isClosed()) {
+			await cdpSession.send("Performance.disable");
+			await cdpSession.detach();
+		}
+	};
+};
+// src/live/zoom-logic.ts
+const UNKNOWN_ZOOM_DEVICE_STATUS = 422;
+const pickZoomChange = (previousDeviceId, nextDeviceId, knownDeviceIds) => {
+	if (nextDeviceId !== null && !knownDeviceIds.includes(nextDeviceId)) throw new HTTPException(UNKNOWN_ZOOM_DEVICE_STATUS, { message: `zoom: no live device with id ${nextDeviceId}` });
+	if (previousDeviceId === nextDeviceId) return {
+		restoreDeviceId: null,
+		zoomDeviceId: null
+	};
+	return {
+		restoreDeviceId: previousDeviceId,
+		zoomDeviceId: nextDeviceId
+	};
+};
+const pickZoomOwnerId = (nextDeviceId, clientId) => {
+	if (nextDeviceId === null) return null;
+	return clientId;
+};
+// src/live/zoom-store.ts
+const ZOOM_QUEUE_KEY = "zoom";
+const zoomControls = /* @__PURE__ */ new Map();
+let zoomedDeviceId = null;
+let zoomOwnerId = null;
+const registerZoomControl = (deviceId, setZoomed) => {
+	zoomControls.set(deviceId, setZoomed);
+	return () => {
+		zoomControls.delete(deviceId);
+		if (zoomedDeviceId === deviceId) {
+			zoomedDeviceId = null;
+			zoomOwnerId = null;
+		}
+	};
+};
+const applyZoomedDevice = async (nextDeviceId, clientId) => {
+	const knownDeviceIds = [...zoomControls.keys()];
+	const { restoreDeviceId, zoomDeviceId } = pickZoomChange(zoomedDeviceId, nextDeviceId, knownDeviceIds);
+	const hasDeviceToRestore = restoreDeviceId !== null;
+	const hasDeviceToZoom = zoomDeviceId !== null;
+	if (hasDeviceToRestore) await zoomControls.get(restoreDeviceId)?.(false);
+	if (hasDeviceToZoom) await zoomControls.get(zoomDeviceId)?.(true);
+	zoomedDeviceId = nextDeviceId;
+	zoomOwnerId = pickZoomOwnerId(nextDeviceId, clientId);
+};
+const changeZoomedDevice = (nextDeviceId, clientId) => runOneAtATime(ZOOM_QUEUE_KEY, () => applyZoomedDevice(nextDeviceId, clientId));
+const releaseClientZoom = (clientId) => runOneAtATime(ZOOM_QUEUE_KEY, async () => {
+	if (!(zoomOwnerId === clientId)) return;
+	await applyZoomedDevice(null, clientId);
+});
+// src/live/screencast.ts
+const PAINT_TIMEOUT_MS = 3e3;
+const waitForPaintedPage = async (page) => {
+	try {
+		await page.waitForFunction(() => {
+			const { body } = document;
+			if (body === null) return false;
+			const hasText = body.innerText.trim().length > 0;
+			const hasMedia = body.querySelector("img, canvas, svg, video") !== null;
+			return hasText || hasMedia;
+		}, void 0, { timeout: PAINT_TIMEOUT_MS });
+	} catch (error) {
+		if (!(error instanceof errors.TimeoutError)) throw error;
+	}
+	await page.evaluate(() => new Promise((onPainted) => {
+		requestAnimationFrame(() => requestAnimationFrame(() => onPainted()));
+	}));
+};
+const startScreencast = async (page, deviceId) => {
+	const cdpSession = await page.context().newCDPSession(page);
+	cdpSession.on("Page.screencastFrame", async (screencastFrame) => {
+		try {
+			await cdpSession.send("Page.screencastFrameAck", { sessionId: screencastFrame.sessionId });
+		} catch (error) {
+			if (page.isClosed()) return;
+			console.error({
+				deviceId,
+				error
+			});
+		}
+		broadcast({
+			kind: "screen",
+			deviceId,
+			imageBase64: screencastFrame.data
+		});
+	});
+	await cdpSession.send("Page.startScreencast", { ...SCREENCAST });
+	let stillQuality = SCREENCAST.quality;
+	const sendStillScreenImage = async () => {
+		await waitForPaintedPage(page);
+		const stillScreenImage = await cdpSession.send("Page.captureScreenshot", {
+			format: SCREENCAST.format,
+			quality: stillQuality
+		});
+		broadcast({
+			kind: "screen",
+			deviceId,
+			imageBase64: stillScreenImage.data
+		});
+	};
+	const sendStillScreenImageOnLoad = () => {
+		sendStillScreenImage().catch((error) => {
+			if (page.isClosed()) return;
+			console.error({
+				deviceId,
+				error
+			});
+		});
+	};
+	page.on("load", sendStillScreenImageOnLoad);
+	sendStillScreenImageOnLoad();
+	const setZoomed = async (isZoomed) => {
+		const screencastSize = isZoomed ? ZOOM_SCREENCAST : SCREENCAST;
+		stillQuality = screencastSize.quality;
+		await cdpSession.send("Page.stopScreencast");
+		await cdpSession.send("Page.startScreencast", {
+			...SCREENCAST,
+			...screencastSize
+		});
+		sendStillScreenImageOnLoad();
+	};
+	const forgetZoomControl = registerZoomControl(deviceId, setZoomed);
+	return async () => {
+		forgetZoomControl();
+		page.off("load", sendStillScreenImageOnLoad);
+		try {
+			await cdpSession.send("Page.stopScreencast");
+		} finally {
+			await cdpSession.detach();
+		}
+	};
+};
+const sendStepScreen = async (page, deviceId) => {
+	await waitForPaintedPage(page);
+	const stepScreenImage = await page.screenshot({
+		type: SCREENCAST.format,
+		quality: SCREENCAST.quality
+	});
+	broadcast({
+		kind: "screen",
+		deviceId,
+		imageBase64: stepScreenImage.toString("base64")
+	});
+};
+// src/devices/device-browsers.ts
+const DEFAULT_PAGE_WATCHERS = {
+	chromium: [
+		startScreencast,
+		startSampling,
+		watchPage
+	],
+	webkit: [],
+	firefox: []
+};
+const BROWSER_TYPES = {
+	chromium,
+	webkit,
+	firefox
+};
+const DEVTOOLS_PORT_FILE = "DevToolsActivePort";
+const USER_DATA_DIR_FLAG = "--user-data-dir=";
+const DEVTOOLS_PORT_TIMEOUT_MS = 5e3;
+const DEVTOOLS_PORT_RETRY_MS = 50;
+const readCdpUrl = async (browserServer) => {
+	const userDataFlag = browserServer.process().spawnargs.find((flag) => flag.startsWith(USER_DATA_DIR_FLAG));
+	if (!(userDataFlag !== void 0)) throw new Error("Device browser started without a user data folder");
+	const portFilePath = `${userDataFlag.slice(16)}/${DEVTOOLS_PORT_FILE}`;
+	const timeout = AbortSignal.timeout(DEVTOOLS_PORT_TIMEOUT_MS);
+	while (!timeout.aborted) {
+		const portFile = await readStoredFile(portFilePath);
+		if (portFile !== null) {
+			const [cdpPort] = portFile.split("\n");
+			return `http://${HUB_HOST}:${cdpPort}`;
+		}
+		await setTimeout$1(DEVTOOLS_PORT_RETRY_MS);
+	}
+	throw new Error("Device browser did not write its remote debugging port");
+};
+const stopPageWatchers = async (stopWatchers, deviceId) => {
+	for (const stopWatching of stopWatchers) try {
+		await stopWatching();
+	} catch (error) {
+		console.error({
+			deviceId,
+			error
+		});
+	}
+};
+const launchBrowserServer = async (browserName) => {
+	const launchSettings = {
+		headless: true,
+		host: HUB_HOST,
+		handleSIGINT: false,
+		handleSIGTERM: false
+	};
+	if (browserName === "chromium") return chromium.launchServer({
+		...launchSettings,
+		args: ["--remote-debugging-port=0"]
+	});
+	return BROWSER_TYPES[browserName].launchServer(launchSettings);
+};
+const connectHubBrowser = async (browserName, wsEndpoint, cdpUrl) => {
+	if (cdpUrl !== null) return chromium.connectOverCDP(cdpUrl);
+	return BROWSER_TYPES[browserName].connect(wsEndpoint);
+};
+const NAME_HELPER_SCRIPT = "globalThis.__name = (target) => target;";
+const startDeviceBrowser = async (devicePreset, pageWatchers = DEFAULT_PAGE_WATCHERS[devicePreset.browserName]) => {
+	const { browserName } = devicePreset;
+	const isChromium = browserName === "chromium";
+	const browserServer = await launchBrowserServer(browserName);
+	try {
+		const wsEndpoint = browserServer.wsEndpoint();
+		const cdpUrl = isChromium ? await readCdpUrl(browserServer) : null;
+		const hubBrowser = await connectHubBrowser(browserName, wsEndpoint, cdpUrl);
+		const deviceId = devicePreset.id;
+		const openPages = [];
+		const watchersByPage = /* @__PURE__ */ new Map();
+		const startPageWatchers = async (page) => {
+			const stopWatchers = [];
+			watchersByPage.set(page, stopWatchers);
+			for (const pageWatcher of pageWatchers) {
+				const stopWatching = await pageWatcher(page, deviceId);
+				stopWatchers.push(stopWatching);
+			}
+		};
+		const forgetPage = async (page) => {
+			const pageIndex = openPages.indexOf(page);
+			if (!(pageIndex !== -1)) return;
+			const wasCurrentPage = pageIndex === openPages.length - 1;
+			openPages.splice(pageIndex, 1);
+			watchersByPage.delete(page);
+			const [newestPage] = openPages.slice(-1);
+			if (wasCurrentPage && newestPage !== void 0) await startPageWatchers(newestPage);
+		};
+		const trackPage = async (page) => {
+			if (openPages.includes(page)) return;
+			if (isChromium) {
+				await emulateDevice(page, devicePreset);
+				await (await page.context().newCDPSession(page)).send("Emulation.setCPUThrottlingRate", { rate: devicePreset.cpuSlowdown });
+			}
+			const [currentPage] = openPages.slice(-1);
+			if (currentPage !== void 0) {
+				const currentStopWatchers = watchersByPage.get(currentPage) ?? [];
+				watchersByPage.delete(currentPage);
+				await stopPageWatchers(currentStopWatchers, deviceId);
+			}
+			openPages.push(page);
+			page.on("close", () => runSafely(() => forgetPage(page)));
+			await startPageWatchers(page);
+		};
+		const runSafely = (task) => {
+			runOneAtATime(wsEndpoint, task).catch((error) => {
+				console.error({
+					deviceId,
+					error
+				});
+			});
+		};
+		const watchBrowserContext = (browserContext) => {
+			browserContext.on("page", (page) => runSafely(() => trackPage(page)));
+			for (const page of browserContext.pages()) runSafely(() => trackPage(page));
+		};
+		if (isChromium) for (const browserContext of hubBrowser.contexts()) watchBrowserContext(browserContext);
+		const openPage = async () => {
+			const browserContext = await hubBrowser.newContext(devicePreset.use);
+			await browserContext.addInitScript(NAME_HELPER_SCRIPT);
+			const page = await browserContext.newPage();
+			await runOneAtATime(wsEndpoint, () => trackPage(page));
+			return page;
+		};
+		const stop = async () => {
+			try {
+				const allStopWatchers = [...watchersByPage.entries()].filter(([page]) => !page.isClosed()).flatMap(([, stopWatchers]) => stopWatchers);
+				await stopPageWatchers(allStopWatchers, deviceId);
+				await hubBrowser.close();
+			} finally {
+				await browserServer.close();
+			}
+		};
+		return {
+			deviceId,
+			browserName,
+			wsEndpoint,
+			cdpUrl,
+			openPage,
+			stop
+		};
+	} catch (error) {
+		await browserServer.close();
+		throw new Error("Device browser failed to start", { cause: error });
+	}
+};
+// src/checks/check-probes.ts
+const TAP_TAGS = "a[href], button, input, [role=button]";
+const readMeasurements = (measureRequest) => {
+	const SELECTOR_DEPTH = 3;
+	const { tapTags, deviceViewport } = measureRequest;
+	const { width: viewportWidth, height: viewportHeight } = deviceViewport;
+	const describeNode = (element) => {
+		const tagName = element.tagName.toLowerCase();
+		const firstClass = element.classList[0] ?? null;
+		return `${tagName}${firstClass === null ? "" : `.${CSS.escape(firstClass)}`}:nth-of-type(${[...element.parentElement?.children ?? []].filter((sibling) => sibling.tagName === element.tagName).indexOf(element) + 1})`;
+	};
+	const describeElement = (element) => {
+		const path = [];
+		let node = element;
+		while (node !== null && node !== document.body) {
+			if (path.length >= SELECTOR_DEPTH) break;
+			path.unshift(describeNode(node));
+			node = node.parentElement;
+		}
+		return path.join(" > ");
+	};
+	const isInsideClippingBox = (element) => {
+		let ancestor = element.parentElement;
+		while (ancestor !== null && ancestor !== document.body) {
+			const { overflowX } = getComputedStyle(ancestor);
+			if (overflowX !== "visible") return true;
+			ancestor = ancestor.parentElement;
+		}
+		return false;
+	};
+	const hasOwnText = (element) => [...element.childNodes].some((childNode) => {
+		const isTextNode = childNode.nodeType === Node.TEXT_NODE;
+		const hasLetters = (childNode.textContent ?? "").trim().length > 0;
+		return isTextNode && hasLetters;
+	});
+	const readSheetRules = (sheet) => {
+		try {
+			return [...sheet.cssRules];
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "SecurityError") return [];
+			throw error;
+		}
+	};
+	const listStyleRules = (rules) => rules.flatMap((rule) => {
+		if (rule instanceof CSSStyleRule) return [rule];
+		return rule instanceof CSSGroupingRule ? listStyleRules([...rule.cssRules]) : [];
+	});
+	const isRuleMatching = (rule, element) => {
+		try {
+			return element.matches(rule.selectorText);
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "SyntaxError") return false;
+			throw error;
+		}
+	};
+	const styleRules = listStyleRules([...document.styleSheets].flatMap(readSheetRules));
+	const listOwnDeclarations = (element) => {
+		const inlineStyle = element.getAttribute("style");
+		const hasInlineStyle = inlineStyle !== null;
+		const ruleDeclarations = styleRules.filter((rule) => isRuleMatching(rule, element)).map((rule) => rule.style.cssText);
+		return hasInlineStyle ? [inlineStyle, ...ruleDeclarations] : ruleDeclarations;
+	};
+	const isTiedToSafeArea = (element, side) => listOwnDeclarations(element).some((declarations) => declarations.includes(`safe-area-inset-${side}`));
+	const viewportContent = document.querySelector("meta[name=\"viewport\"]")?.getAttribute("content") ?? null;
+	const isViewportCover = viewportContent !== null && /viewport-fit\s*=\s*cover/i.test(viewportContent);
+	const measured = [...document.querySelectorAll("body *")].map((element) => ({
+		selector: describeElement(element),
+		style: getComputedStyle(element),
+		box: element.getBoundingClientRect(),
+		element
+	}));
+	const isRightToLeft = getComputedStyle(document.documentElement).direction === "rtl";
+	const measureOverflowPx = (box) => isRightToLeft ? -(box.left + window.scrollX) : box.right - viewportWidth;
+	const pastEdge = measured.filter(({ element }) => !isInsideClippingBox(element)).map(({ selector, box }) => ({
+		selector,
+		overflowPx: Math.round(measureOverflowPx(box))
+	})).filter((pastEdgeBox) => pastEdgeBox.overflowPx > 0).sort((first, second) => second.overflowPx - first.overflowPx);
+	const clippedSelectors = measured.filter(({ style, element }) => {
+		const hidesOverflow = style.overflowX === "hidden" || style.textOverflow === "ellipsis";
+		const isWiderThanBox = element.scrollWidth > element.clientWidth;
+		return hidesOverflow && isWiderThanBox && hasOwnText(element);
+	}).map((clippedBox) => clippedBox.selector);
+	const pinnedBoxes = measured.filter(({ style }) => ["fixed", "sticky"].includes(style.position)).map(({ selector, box, style, element }) => ({
+		selector,
+		top: box.top,
+		bottom: box.bottom,
+		paddingTop: Number.parseFloat(style.paddingTop),
+		paddingBottom: Number.parseFloat(style.paddingBottom),
+		cssSafeAreaSides: {
+			top: isTiedToSafeArea(element, "top"),
+			bottom: isTiedToSafeArea(element, "bottom")
+		}
+	}));
+	const tapTargets = measured.filter(({ element, style, box }) => {
+		const isHidden = style.display === "none" || style.visibility === "hidden";
+		const hasNoSize = box.width === 0 || box.height === 0;
+		const parentLength = element.parentElement?.textContent?.length ?? 0;
+		const ownLength = element.textContent?.length ?? 0;
+		const isInlineLink = element.tagName === "A" && style.display === "inline" && parentLength > ownLength;
+		return element.matches(tapTags) && !isHidden && !hasNoSize && !isInlineLink;
+	}).map(({ selector, box }) => ({
+		selector,
+		width: box.width,
+		height: box.height
+	}));
+	return {
+		viewportWidth,
+		viewportHeight,
+		widestPastEdge: pastEdge[0] ?? null,
+		clippedSelectors,
+		pinnedBoxes,
+		tapTargets,
+		isViewportCover
+	};
+};
+const measurePage = (page, deviceViewport) => page.evaluate(readMeasurements, {
+	tapTags: TAP_TAGS,
+	deviceViewport
+});
+// src/live/navigation-retry.ts
+const NAVIGATION_SETTLE_TIMEOUT_MS = 3e3;
+const NAVIGATION_SETTLE_PAUSE_MS = 200;
+const NAVIGATION_RACE_MESSAGE = "Execution context was destroyed";
+const waitForNewPage = async (page) => {
+	await page.waitForTimeout(NAVIGATION_SETTLE_PAUSE_MS);
+	try {
+		await page.waitForLoadState("domcontentloaded", { timeout: NAVIGATION_SETTLE_TIMEOUT_MS });
+	} catch (error) {
+		if (!(error instanceof errors.TimeoutError)) throw error;
+	}
+};
+const retryAfterNavigation = async (page, readPage) => {
+	try {
+		return await readPage();
+	} catch (error) {
+		if (!pickErrorMessage(error).includes(NAVIGATION_RACE_MESSAGE)) throw error;
+		await waitForNewPage(page);
+		return readPage();
+	}
+};
+// src/commands/command-steps.ts
+const ACTION_TIMEOUT_MS = 1e4;
+const performCommand = async (devicePage, hubCommand) => {
+	const { page, device } = devicePage;
+	const actionTimeout = { timeout: ACTION_TIMEOUT_MS };
+	switch (hubCommand.commandName) {
+		case "open":
+			await page.goto(hubCommand.url, actionTimeout);
+			return;
+		case "sweep":
+			await page.goto(hubCommand.url, actionTimeout);
+			await waitForPaintedPage(page);
+			return;
+		case "tap": {
+			const target = page.getByRole(hubCommand.role, { name: hubCommand.name });
+			if (device.use.hasTouch === true) {
+				await target.tap(actionTimeout);
+				return;
+			}
+			await target.click(actionTimeout);
+			return;
+		}
+		case "fill":
+			await page.getByRole(hubCommand.role, { name: hubCommand.name }).fill(hubCommand.with, actionTimeout);
+			return;
+		case "scroll": {
+			const isScrollToTop = hubCommand.to === "top";
+			await page.evaluate((isTop) => {
+				const bottomOffset = document.documentElement.scrollHeight;
+				window.scrollTo(0, isTop ? 0 : bottomOffset);
+			}, isScrollToTop);
+			return;
+		}
+		case "expect":
+			await page.getByText(hubCommand.text).first().waitFor({
+				state: "visible",
+				...actionTimeout
+			});
+			return;
+		case "check":
+		case "shot": return;
+	}
+};
+const tryCommand = async (devicePage, hubCommand) => {
+	try {
+		await performCommand(devicePage, hubCommand);
+		return null;
+	} catch (error) {
+		return pickErrorMessage(error);
+	}
+};
+const saveShot = async (devicePage, stepTarget) => {
+	const { rootFolder, runId, stepId } = stepTarget;
+	const shotPath = createShotPath(runId, stepId, devicePage.device.id);
+	const shotBytes = await devicePage.page.screenshot({ type: "png" });
+	await writeStoredFile(join(rootFolder, shotPath), shotBytes);
+	return shotPath;
+};
+const runStepOnDevice = async (devicePage, stepTarget) => {
+	const { page, device, hasLiveScreen } = devicePage;
+	const { hubCommand } = stepTarget;
+	const startedAt = Date.now();
+	releaseDeviceScreen(device.id);
+	const actionErrorMessage = await tryCommand(devicePage, hubCommand);
+	const deviceViewport = pickDeviceViewport(device);
+	const measurements = await retryAfterNavigation(page, () => measurePage(page, deviceViewport));
+	const checkDevice = pickCheckDevice(device);
+	const findings = listFindings(measurements, checkDevice);
+	const durationMs = Date.now() - startedAt;
+	const failureMessage = pickFailureMessage(actionErrorMessage, findings);
+	const isStepFailed = failureMessage !== null;
+	const isShotCommand = hubCommand.commandName === "shot";
+	const isSweepCommand = hubCommand.commandName === "sweep";
+	const shotPath = isStepFailed || isShotCommand || isSweepCommand ? await saveShot(devicePage, stepTarget) : null;
+	if (!hasLiveScreen) await retryAfterNavigation(page, () => sendStepScreen(page, device.id));
+	if (isStepFailed) return {
+		deviceAnswer: {
+			status: "failed",
+			deviceId: device.id,
+			durationMs,
+			message: failureMessage,
+			shotPath
+		},
+		findings
+	};
+	return {
+		deviceAnswer: {
+			status: "ok",
+			deviceId: device.id,
+			durationMs,
+			shotPath
+		},
+		findings
+	};
+};
+// src/live/live-command-schema.ts
+const commandNoticeSchema = z.object({
+	commandName: z.string().min(1),
+	status: z.enum(["ok", "failed"]),
+	line: z.string(),
+	sentAt: z.number().int()
+});
+// src/runs/interactive-run.ts
+const hubInteractiveRun = { runId: null };
+const createCommandQueueKey = (rootFolder) => `commands:${rootFolder}`;
+const readHubInteractiveRun = async (rootFolder) => {
+	const heldRunId = hubInteractiveRun.runId;
+	if (heldRunId === null) return null;
+	return readRun(rootFolder, heldRunId);
+};
+const readInteractiveRun = async (rootFolder) => {
+	const heldRun = await readHubInteractiveRun(rootFolder);
+	if (isRunOpen(heldRun)) return heldRun;
+	const openedRun = await createRun(rootFolder, "cli", "steps");
+	hubInteractiveRun.runId = openedRun.runId;
+	return openedRun;
+};
+const closeInteractiveRun = async (rootFolder) => {
+	const commandQueueKey = createCommandQueueKey(rootFolder);
+	await runOneAtATime(commandQueueKey, async () => {
+		const heldRun = await readHubInteractiveRun(rootFolder);
+		hubInteractiveRun.runId = null;
+		if (!isRunOpen(heldRun)) return;
+		await closeRun(rootFolder, heldRun.runId);
+	});
+};
+// src/flows/flows-logic.ts
+const listFlowCommands = (flow) => flow.steps.map((step) => ({
+	...step,
+	deviceIds: flow.devices
+}));
+const listFlowBatches = (flowPaths, flowsPerBatch) => {
+	const batchCount = Math.ceil(flowPaths.length / flowsPerBatch);
+	return [...Array(batchCount).keys()].map((batchIndex) => flowPaths.slice(batchIndex * flowsPerBatch, (batchIndex + 1) * flowsPerBatch));
+};
+const createFailedFlowAnswer = (flowPath, problemLine) => ({
+	flowPath,
+	status: "failed",
+	runId: null,
+	failures: [],
+	problemLine
+});
+const createFlowAnswer = (flowPath, stepReplies) => {
+	const runId = stepReplies.at(-1)?.runId ?? null;
+	const failedReply = stepReplies.find(({ status }) => status === "failed");
+	if (failedReply === void 0) return {
+		flowPath,
+		status: "ok",
+		runId,
+		failures: [],
+		problemLine: null
+	};
+	const problemLine = failedReply.failures.length > 0 ? null : failedReply.line;
+	return {
+		flowPath,
+		status: "failed",
+		runId,
+		failures: failedReply.failures,
+		problemLine
+	};
+};
+const summarizeFlows = (flowAnswers) => {
+	const failedCount = flowAnswers.filter(({ status }) => status === "failed").length;
+	const okCount = flowAnswers.length - failedCount;
+	const runId = flowAnswers.at(-1)?.runId ?? null;
+	const status = failedCount === 0 && okCount > 0 ? "ok" : "failed";
+	const summaryLine = createReplyLine({
+		unit: "flow",
+		okCount,
+		warnCount: 0,
+		failedCount,
+		runId
+	});
+	const hasProblemLine = ({ problemLine }) => problemLine !== null;
+	return {
+		status,
+		line: [summaryLine, ...flowAnswers.filter(hasProblemLine).map(({ flowPath, problemLine }) => `${flowPath}: ${problemLine}`)].join(" · "),
+		runId,
+		failures: flowAnswers.flatMap((flowAnswer) => flowAnswer.failures)
+	};
+};
+// src/sweep/sweep-extra-devices.ts
+const closeExtraBrowsers = async (extraBrowsers) => {
+	const closeReplies = await Promise.allSettled([...extraBrowsers.values()].map((extraBrowser) => extraBrowser.close()));
+	for (const closeReply of closeReplies) if (closeReply.status === "rejected") console.error({ error: closeReply.reason });
+};
+const withExtraBrowsers = async (extraPresets, visitWithBrowsers) => {
+	const extraBrowsers = /* @__PURE__ */ new Map();
+	const browserNames = new Set(extraPresets.map(({ browserName }) => browserName));
+	try {
+		for (const browserName of browserNames) {
+			const extraBrowser = await BROWSER_TYPES[browserName].launch({ headless: true });
+			extraBrowsers.set(browserName, extraBrowser);
+		}
+		return await visitWithBrowsers(extraBrowsers);
+	} finally {
+		await closeExtraBrowsers(extraBrowsers);
+	}
+};
+const withExtraDevicePage = async (extraBrowsers, devicePreset, visitDevicePage) => {
+	const extraBrowser = extraBrowsers.get(devicePreset.browserName);
+	if (extraBrowser === void 0) throw new Error(`No sweep browser for ${devicePreset.browserName}`);
+	const browserContext = await extraBrowser.newContext(devicePreset.use);
+	try {
+		await browserContext.addInitScript(NAME_HELPER_SCRIPT);
+		const page = await browserContext.newPage();
+		if (devicePreset.browserName === "chromium") await emulateDevice(page, devicePreset);
+		return await visitDevicePage({
+			device: devicePreset,
+			page,
+			hasLiveScreen: true
+		});
+	} finally {
+		await browserContext.close();
+	}
+};
+// src/sweep/sweep-logic.ts
+const BAD_START_URL_STATUS = 422;
+const BEFORE_FAILED_PREFIX = "before flow failed: ";
+const WEB_PROTOCOLS = ["http:", "https:"];
+const NOFOLLOW_PATTERN = /(^|\s)nofollow(\s|$)/i;
+const DOWNLOAD_EXTENSIONS = [
+	".pdf",
+	".zip",
+	".gz",
+	".tar",
+	".dmg",
+	".exe",
+	".apk",
+	".csv",
+	".xml",
+	".json",
+	".txt",
+	".mp3",
+	".mp4",
+	".mov",
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".svg",
+	".ico"
+];
+const SITEMAP_LOC_PATTERN = /<loc>([^<]*)<\/loc>/g;
+const XML_ENTITY_PATTERN = /&(?:lt|gt|quot|apos|amp);/g;
+const XML_ENTITIES = {
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&apos;": "'",
+	"&amp;": "&"
+};
+const createRoutePath = (href, baseUrl) => {
+	if (!URL.canParse(href, baseUrl)) return null;
+	const linkUrl = new URL(href, baseUrl);
+	const isNotWebPage = !WEB_PROTOCOLS.includes(linkUrl.protocol);
+	const isOtherOrigin = linkUrl.origin !== new URL(baseUrl).origin;
+	const pathname = linkUrl.pathname.toLowerCase();
+	const isFileDownload = DOWNLOAD_EXTENSIONS.some((extension) => pathname.endsWith(extension));
+	const isHostPath = linkUrl.pathname.startsWith("//");
+	if (isNotWebPage || isOtherOrigin || isFileDownload || isHostPath) return null;
+	return `${linkUrl.pathname}${linkUrl.search}`;
+};
+const pickRoutes = (hrefs, baseUrl) => hrefs.map((href) => createRoutePath(href, baseUrl)).filter((route) => route !== null);
+const pickLinkRoutes = (pageLinks, startUrl) => {
+	const followedHrefs = pageLinks.filter(({ rel, isDownload }) => !isDownload && !NOFOLLOW_PATTERN.test(rel)).map(({ href }) => href);
+	return pickRoutes(followedHrefs, startUrl);
+};
+const parseSitemapLocs = (sitemapXml) => [...sitemapXml.matchAll(SITEMAP_LOC_PATTERN)].map(([, loc]) => loc.trim().replace(XML_ENTITY_PATTERN, (entity) => XML_ENTITIES[entity]));
+const mergeRoutes = (routeLists, maxRoutes) => [...new Set(routeLists.flat())].slice(0, maxRoutes);
+const pickStartRoute = (startUrl) => {
+	const startRoute = createRoutePath(startUrl, startUrl);
+	if (startRoute === null) throw new HTTPException(BAD_START_URL_STATUS, { message: "Sweep needs an http or https url" });
+	return startRoute;
+};
+const createRouteUrl = (route, startUrl) => {
+	return `${new URL(startUrl).origin}${route}`;
+};
+const hasLeftOrigin = (pageUrl, startUrl) => {
+	return new URL(pageUrl).origin !== new URL(startUrl).origin;
+};
+const createLeftOriginStep = (deviceStep) => {
+	const { deviceId, durationMs, shotPath } = deviceStep.deviceAnswer;
+	return {
+		deviceAnswer: {
+			status: "failed",
+			deviceId,
+			durationMs,
+			message: "left the app origin",
+			shotPath
+		},
+		findings: deviceStep.findings
+	};
+};
+const createCrashedStep = (deviceId, durationMs, error) => ({
+	deviceAnswer: {
+		status: "failed",
+		deviceId,
+		durationMs,
+		message: pickErrorMessage(error),
+		shotPath: null
+	},
+	findings: []
+});
+const splitDeviceIds = (chosenIds, runningIds) => ({
+	gridIds: chosenIds.filter((deviceId) => runningIds.includes(deviceId)),
+	extraIds: chosenIds.filter((deviceId) => !runningIds.includes(deviceId))
+});
+const pickSweepDevices = (deviceIds, runningIds, catalogIds) => {
+	const knownIds = [.../* @__PURE__ */ new Set([...runningIds, ...catalogIds])];
+	if (deviceIds === "all") return splitDeviceIds(knownIds, runningIds);
+	const chosenIds = pickDeviceIds(deviceIds === null ? runningIds : knownIds, deviceIds);
+	return splitDeviceIds(chosenIds, runningIds);
+};
+const createBeforeFailure = (deviceFailure) => {
+	const [firstLine] = deviceFailure.message.split("\n");
+	return {
+		...deviceFailure,
+		message: `${BEFORE_FAILED_PREFIX}${firstLine}`
+	};
+};
+const isDeviceVisited = (deviceVisit) => deviceVisit.kind === "visited";
+const isBeforeFailed = (deviceVisit) => deviceVisit.kind === "before-failed";
+const pickVisitedRouteSteps = (deviceVisits) => deviceVisits.filter(isDeviceVisited).map(({ routeSteps }) => routeSteps);
+const pickBeforeFailures = (deviceVisits) => deviceVisits.filter(isBeforeFailed).map(({ beforeFailure }) => beforeFailure);
+const listBeforeRunSteps = (beforeFailures, routeCount, startedAt) => {
+	if (beforeFailures.length === 0) return [];
+	return [createCommandRunStep({
+		stepId: createStepId(routeCount + 1),
+		title: "before flow",
+		startedAt,
+		deviceSteps: beforeFailures.map((deviceAnswer) => ({
+			deviceAnswer,
+			findings: []
+		}))
+	})];
+};
+const createSweepSteps = (routes, routeStepsByDevice) => {
+	if (routeStepsByDevice.length === 0) return [];
+	return routes.map((route, routeIndex) => {
+		const routeSteps = routeStepsByDevice.map((deviceRouteSteps) => deviceRouteSteps[routeIndex]);
+		const startTimes = routeSteps.map(({ startedAt }) => startedAt);
+		return {
+			route,
+			runStep: createCommandRunStep({
+				stepId: createStepId(routeIndex + 1),
+				title: `sweep ${route}`,
+				startedAt: Math.min(...startTimes),
+				deviceSteps: routeSteps.map(({ deviceStep }) => deviceStep)
+			})
+		};
+	});
+};
+const summarizeSweep = (sweepSteps, beforeRunSteps, runId) => {
+	const routeRunSteps = sweepSteps.map(({ runStep }) => runStep);
+	const { okCount, warnCount, failedCount } = countDeviceStatuses([...routeRunSteps, ...beforeRunSteps]);
+	const deviceCount = okCount + warnCount + failedCount;
+	const routeFailures = sweepSteps.flatMap(({ route, runStep }) => listDeviceFailures(runStep).map((deviceFailure) => ({
+		...deviceFailure,
+		message: `${route} ${deviceFailure.message}`
+	})));
+	const failures = [...beforeRunSteps.flatMap(listDeviceFailures), ...routeFailures];
+	const shotCount = routeRunSteps.flatMap((runStep) => runStep.deviceAnswers).filter(({ shotPath }) => shotPath !== null).length;
+	const findingCount = sweepSteps.reduce((total, { runStep }) => total + runStep.findings.length, 0);
+	const warnParts = warnCount > 0 ? [`${warnCount} warn`] : [];
+	const hasFailure = failedCount > 0;
+	const failedParts = hasFailure ? [`${failedCount} failed`] : [];
+	const lineParts = [
+		countUnits(sweepSteps.length, "route"),
+		countUnits(deviceCount, "device"),
+		countUnits(shotCount, "shot"),
+		countUnits(findingCount, "finding"),
+		`${okCount} ok`,
+		...warnParts,
+		...failedParts,
+		`report ${runId}`
+	];
+	return {
+		status: hasFailure ? "failed" : "ok",
+		line: lineParts.join(" · "),
+		runId,
+		failures
+	};
+};
+// src/sweep/sweep-routes.ts
+const SITEMAP_PATH = "/sitemap.xml";
+const LINK_SELECTOR = "a[href]";
+const readPageLinks = async (page) => page.evaluate((linkSelector) => [...document.querySelectorAll(linkSelector)].map((anchor) => ({
+	href: anchor.href,
+	rel: anchor.rel,
+	isDownload: anchor.hasAttribute("download")
+})), LINK_SELECTOR);
+const readRouteLinks = async (page, routeUrl, startUrl) => {
+	try {
+		await page.goto(routeUrl, { timeout: ACTION_TIMEOUT_MS });
+		await waitForPaintedPage(page);
+		const pageUrl = page.url();
+		if (hasLeftOrigin(pageUrl, startUrl)) return [];
+		const pageLinks = await readPageLinks(page);
+		return pickLinkRoutes(pageLinks, startUrl);
+	} catch (error) {
+		console.error({
+			routeUrl,
+			error
+		});
+		return [];
+	}
+};
+const crawlRoutes = async (page, startUrl, maxRoutes) => {
+	const knownRoutes = [pickStartRoute(startUrl)];
+	for (const route of knownRoutes) {
+		if (knownRoutes.length >= maxRoutes) break;
+		const routeUrl = createRouteUrl(route, startUrl);
+		const foundRoutes = await readRouteLinks(page, routeUrl, startUrl);
+		const mergedRoutes = mergeRoutes([knownRoutes, foundRoutes], maxRoutes);
+		knownRoutes.push(...mergedRoutes.slice(knownRoutes.length));
+	}
+	return knownRoutes;
+};
+const readSitemapRoutes = async (startUrl) => {
+	const sitemapUrl = createRouteUrl(SITEMAP_PATH, startUrl);
+	try {
+		const sitemapReply = await fetch(sitemapUrl, { signal: AbortSignal.timeout(ACTION_TIMEOUT_MS) });
+		if (!sitemapReply.ok) return [];
+		const sitemapXml = await sitemapReply.text();
+		const sitemapLocs = parseSitemapLocs(sitemapXml);
+		return pickRoutes(sitemapLocs, startUrl);
+	} catch (error) {
+		console.error({
+			sitemapUrl,
+			error
+		});
+		return [];
+	}
+};
+const listSweepRoutes = async (crawlPage, routeSources) => {
+	const { startUrl, maxRoutes, configuredRoutes } = routeSources;
+	const crawledRoutes = await crawlRoutes(crawlPage, startUrl, maxRoutes);
+	const sitemapRoutes = await readSitemapRoutes(startUrl);
+	const yamlRoutes = pickRoutes(configuredRoutes, startUrl);
+	return mergeRoutes([
+		crawledRoutes,
+		sitemapRoutes,
+		yamlRoutes
+	], maxRoutes);
+};
+// src/sweep/sweep-run.ts
+const runStepOrCrash = async (devicePage, stepTarget) => {
+	const startedAt = Date.now();
+	try {
+		return await runStepOnDevice(devicePage, stepTarget);
+	} catch (error) {
+		console.error({
+			deviceId: devicePage.device.id,
+			error
+		});
+		const durationMs = Date.now() - startedAt;
+		return createCrashedStep(devicePage.device.id, durationMs, error);
+	}
+};
+const runRouteOnDevice = async (devicePage, stepStart, routeUrl) => {
+	const startedAt = Date.now();
+	try {
+		const deviceStep = await runStepOnDevice(devicePage, stepStart);
+		const pageUrl = devicePage.page.url();
+		return hasLeftOrigin(pageUrl, routeUrl) ? createLeftOriginStep(deviceStep) : deviceStep;
+	} catch (error) {
+		console.error({
+			deviceId: devicePage.device.id,
+			error
+		});
+		const durationMs = Date.now() - startedAt;
+		return createCrashedStep(devicePage.device.id, durationMs, error);
+	}
+};
+const sweepDevice = async (deviceSweep) => {
+	const { devicePage, rootFolder, runId, routes, sweepCommand } = deviceSweep;
+	const routeSteps = [];
+	for (const [routeIndex, route] of routes.entries()) {
+		const startedAt = Date.now();
+		const routeUrl = createRouteUrl(route, sweepCommand.url);
+		const stepTarget = {
+			rootFolder,
+			runId,
+			stepId: createStepId(routeIndex + 1),
+			hubCommand: {
+				...sweepCommand,
+				url: routeUrl
+			}
+		};
+		const deviceStep = await runRouteOnDevice(devicePage, stepTarget, routeUrl);
+		routeSteps.push({
+			startedAt,
+			deviceStep
+		});
+	}
+	return routeSteps;
+};
+const runBeforeSteps = async (sweepRunStart, devicePage) => {
+	const { rootFolder, runId, sweepCommand } = sweepRunStart;
+	const { beforeSteps } = sweepCommand;
+	if (beforeSteps === null) return null;
+	for (const [stepIndex, hubCommand] of beforeSteps.entries()) {
+		const stepTarget = {
+			rootFolder,
+			runId,
+			stepId: `before-${stepIndex + 1}`,
+			hubCommand
+		};
+		const { deviceAnswer } = await runStepOrCrash(devicePage, stepTarget);
+		if (deviceAnswer.status === "failed") return createBeforeFailure(deviceAnswer);
+	}
+	return null;
+};
+const prepareGridPage = async (sweepRunStart, devicePage) => {
+	const beforeFailure = await runBeforeSteps(sweepRunStart, devicePage);
+	if (beforeFailure !== null) return {
+		kind: "before-failed",
+		beforeFailure
+	};
+	return {
+		kind: "ready",
+		devicePage
+	};
+};
+const visitReadyPage = async (deviceSweep) => {
+	return {
+		kind: "visited",
+		routeSteps: await sweepDevice(deviceSweep)
+	};
+};
+const createCrawlPages = (sweepRunStart) => {
+	const { sweepCommand, configuredRoutes } = sweepRunStart;
+	return {
+		startUrl: sweepCommand.url,
+		maxRoutes: sweepCommand.maxRoutes,
+		configuredRoutes
+	};
+};
+const visitExtraDevice = (extraBrowsers, extraPreset, sweepRoutes) => withExtraDevicePage(extraBrowsers, extraPreset, async (devicePage) => {
+	const { sweepRunStart, routes } = sweepRoutes;
+	const beforeFailure = await runBeforeSteps(sweepRunStart, devicePage);
+	if (beforeFailure !== null) return {
+		kind: "before-failed",
+		beforeFailure
+	};
+	return visitReadyPage({
+		...sweepRunStart,
+		devicePage,
+		routes
+	});
+});
+const visitCrawlingExtraDevice = (extraBrowsers, extraPreset, sweepRunStart) => withExtraDevicePage(extraBrowsers, extraPreset, async (devicePage) => {
+	const beforeFailure = await runBeforeSteps(sweepRunStart, devicePage);
+	if (beforeFailure !== null) return {
+		routes: null,
+		deviceVisit: {
+			kind: "before-failed",
+			beforeFailure
+		}
+	};
+	const crawlPages = createCrawlPages(sweepRunStart);
+	const routes = await listSweepRoutes(devicePage.page, crawlPages);
+	return {
+		routes,
+		deviceVisit: await visitReadyPage({
+			...sweepRunStart,
+			devicePage,
+			routes
+		})
+	};
+});
+const visitExtraDevices = async (extraBrowsers, extraPresets, sweepRoutes) => {
+	const extraIds = extraPresets.map(({ id }) => id);
+	const deviceVisits = [];
+	for (const batchIds of listFlowBatches(extraIds, 4)) {
+		const batchPresets = extraPresets.filter(({ id }) => batchIds.includes(id));
+		const batchVisits = await Promise.all(batchPresets.map((extraPreset) => visitExtraDevice(extraBrowsers, extraPreset, sweepRoutes)));
+		deviceVisits.push(...batchVisits);
+	}
+	return deviceVisits;
+};
+const visitExtraDevicesWithoutGrid = async (sweepRunStart, extraBrowsers, extraPresets) => {
+	const deviceVisits = [];
+	for (const [presetIndex, extraPreset] of extraPresets.entries()) {
+		const crawlingVisit = await visitCrawlingExtraDevice(extraBrowsers, extraPreset, sweepRunStart);
+		deviceVisits.push(crawlingVisit.deviceVisit);
+		const { routes } = crawlingVisit;
+		if (routes !== null) {
+			const restPresets = extraPresets.slice(presetIndex + 1);
+			const restVisits = await visitExtraDevices(extraBrowsers, restPresets, {
+				sweepRunStart,
+				routes
+			});
+			return {
+				routes,
+				deviceVisits: [...deviceVisits, ...restVisits]
+			};
+		}
+	}
+	return {
+		routes: [],
+		deviceVisits
+	};
+};
+const visitDevices = async (sweepRunStart, gridPages, extraPresets) => {
+	const preparedPages = await Promise.all(gridPages.map((gridPage) => prepareGridPage(sweepRunStart, gridPage)));
+	const readyGridPages = preparedPages.filter((preparedPage) => preparedPage.kind === "ready").map(({ devicePage }) => devicePage);
+	const gridFailureVisits = preparedPages.filter((preparedPage) => preparedPage.kind === "before-failed");
+	return withExtraBrowsers(extraPresets, async (extraBrowsers) => {
+		const [crawlGridPage] = readyGridPages;
+		if (!(crawlGridPage !== void 0)) {
+			const extraVisits = await visitExtraDevicesWithoutGrid(sweepRunStart, extraBrowsers, extraPresets);
+			const deviceVisits = [...gridFailureVisits, ...extraVisits.deviceVisits];
+			return {
+				routes: extraVisits.routes,
+				deviceVisits
+			};
+		}
+		const crawlPages = createCrawlPages(sweepRunStart);
+		const routes = await listSweepRoutes(crawlGridPage.page, crawlPages);
+		const sweepRoutes = {
+			sweepRunStart,
+			routes
+		};
+		const [gridVisits, extraVisits] = await Promise.all([Promise.all(readyGridPages.map((devicePage) => visitReadyPage({
+			...sweepRunStart,
+			devicePage,
+			routes
+		}))), visitExtraDevices(extraBrowsers, extraPresets, sweepRoutes)]);
+		return {
+			routes,
+			deviceVisits: [
+				...gridFailureVisits,
+				...gridVisits,
+				...extraVisits
+			]
+		};
+	});
+};
+const saveSweepRun = async ({ rootFolder, runId }, runSteps, sweepReply) => {
+	for (const runStep of runSteps) await saveRunEvent(rootFolder, runId, {
+		kind: "step-end",
+		step: runStep
+	});
+	const runStatus = sweepReply.status === "ok" ? "ok" : "failed";
+	await saveRunEvent(rootFolder, runId, {
+		kind: "run-end",
+		status: runStatus
+	});
+};
+const broadcastSweepRun = (runId, sweepSteps) => {
+	const findings = sweepSteps.flatMap(({ runStep }) => runStep.findings);
+	for (const finding of findings) broadcast({
+		kind: "finding",
+		finding
+	});
+	broadcast({
+		kind: "run",
+		runId
+	});
+};
+const runSweep = async (rootFolder, devicePages, sweepCommand) => {
+	const devicesFile = await readDevicesFile(rootFolder);
+	const runningIds = devicePages.map(({ device }) => device.id);
+	const catalogIds = DEVICE_CATALOG.map(({ id }) => id);
+	const { gridIds, extraIds } = pickSweepDevices(sweepCommand.deviceIds, runningIds, catalogIds);
+	const gridPages = devicePages.filter(({ device }) => gridIds.includes(device.id));
+	const extraPresets = extraIds.map((extraId) => findCatalogPreset(extraId, devicesFile.viewportModes[extraId] ?? "full-screen"));
+	const { runId } = await createRun(rootFolder, "cli", "sweep");
+	const sweepRunStart = {
+		rootFolder,
+		runId,
+		sweepCommand,
+		configuredRoutes: devicesFile.routes
+	};
+	try {
+		const startedAt = Date.now();
+		const { routes, deviceVisits } = await visitDevices(sweepRunStart, gridPages, extraPresets);
+		const routeStepsByDevice = pickVisitedRouteSteps(deviceVisits);
+		const beforeFailures = pickBeforeFailures(deviceVisits);
+		const sweepSteps = createSweepSteps(routes, routeStepsByDevice);
+		const beforeRunSteps = listBeforeRunSteps(beforeFailures, sweepSteps.length, startedAt);
+		const sweepReply = summarizeSweep(sweepSteps, beforeRunSteps, runId);
+		const runSteps = [...sweepSteps.map(({ runStep }) => runStep), ...beforeRunSteps];
+		await saveSweepRun(sweepRunStart, runSteps, sweepReply);
+		broadcastSweepRun(runId, sweepSteps);
+		return sweepReply;
+	} catch (error) {
+		try {
+			await saveRunEvent(rootFolder, runId, {
+				kind: "run-end",
+				status: "failed"
+			});
+		} catch (saveError) {
+			console.error({
+				runId,
+				saveError
+			});
+			throw new Error("Sweep failed and its run end was not saved", { cause: error });
+		}
+		throw error;
+	}
+};
+// src/commands/commands-routes.ts
+const runCommand = async (rootFolder, devicePages, hubCommand) => {
+	if (hubCommand.commandName === "sweep") return runSweep(rootFolder, devicePages, hubCommand);
+	const chosenPages = pickChosenPages(devicePages, hubCommand.deviceIds);
+	const run = await readInteractiveRun(rootFolder);
+	const stepTarget = {
+		rootFolder,
+		runId: run.runId,
+		stepId: pickStepId(run.steps),
+		hubCommand
+	};
+	const startedAt = Date.now();
+	const deviceSteps = await Promise.all(chosenPages.map((devicePage) => runStepOnDevice(devicePage, stepTarget)));
+	const runStep = createCommandRunStep({
+		stepId: stepTarget.stepId,
+		title: createStepTitle(hubCommand),
+		startedAt,
+		deviceSteps
+	});
+	const { findings } = runStep;
+	await saveRunEvent(rootFolder, run.runId, {
+		kind: "step-end",
+		step: runStep
+	});
+	for (const finding of findings) broadcast({
+		kind: "finding",
+		finding
+	});
+	broadcast({
+		kind: "run",
+		runId: run.runId
+	});
+	return summarizeCommand(runStep, run.runId);
+};
+const createCommandsRoutes = (rootFolder, devicePages) => new Hono().get("/app", (c) => {
+	const pageUrls = devicePages.map(({ page }) => page.url());
+	return c.json(pickOpenApp(pageUrls));
+}).post("/", zValidator("json", hubCommandSchema, rejectInvalidRequest), async (c) => {
+	const hubCommand = c.req.valid("json");
+	const commandQueueKey = createCommandQueueKey(rootFolder);
+	const commandReply = await runOneAtATime(commandQueueKey, () => runCommand(rootFolder, devicePages, hubCommand));
+	const commandNotice = commandNoticeSchema.parse({
+		commandName: hubCommand.commandName,
+		status: commandReply.status,
+		line: commandReply.line,
+		sentAt: Date.now()
+	});
+	broadcast({
+		kind: "command",
+		commandNotice
+	});
+	return c.json(commandReply);
+});
+// src/devices/devices-routes.ts
+const CREATED_STATUS$1 = 201;
+const syncRunningDevices = async (syncGrid, changedFile) => {
+	if (syncGrid === null) return;
+	await syncGrid(pickGridDevices(changedFile));
+};
+const createDevicesRoutes = (rootFolder, syncGrid = null) => new Hono().get("/", async (c) => {
+	const devicesFile = await readDevicesFile(rootFolder);
+	return c.json(pickGridDevices(devicesFile));
+}).get("/catalog", async (c) => {
+	const devicesFile = await readDevicesFile(rootFolder);
+	return c.json(listCatalogReplies(devicesFile));
+}).post("/", zValidator("json", customDeviceSchema, rejectInvalidRequest), async (c) => {
+	const customDevice = c.req.valid("json");
+	const changedFile = await updateDevicesFile(rootFolder, (devicesFile) => {
+		const gridDevices = pickGridDevices(devicesFile);
+		const takenDevices = [...DEVICE_CATALOG, ...gridDevices];
+		const checkedDevice = checkNewDevice(customDevice, takenDevices);
+		return {
+			...devicesFile,
+			devices: [...devicesFile.devices, checkedDevice]
+		};
+	});
+	await syncRunningDevices(syncGrid, changedFile);
+	const devicePreset = createPresetFromCustomDevice(customDevice);
+	return c.json(devicePreset, CREATED_STATUS$1);
+}).put("/grid", zValidator("json", gridUpdateSchema, rejectInvalidRequest), async (c) => {
+	const { deviceIds } = c.req.valid("json");
+	const changedFile = await updateDevicesFile(rootFolder, (devicesFile) => replaceGrid(devicesFile, deviceIds));
+	await syncRunningDevices(syncGrid, changedFile);
+	return c.json({ deviceIds: changedFile.grid });
+}).delete("/:deviceId", async (c) => {
+	const deviceId = c.req.param("deviceId");
+	const changedFile = await updateDevicesFile(rootFolder, (devicesFile) => checkDeviceRemoval(devicesFile, deviceId));
+	await syncRunningDevices(syncGrid, changedFile);
+	return c.json({ deviceId });
+});
+// src/live/live-test-schema.ts
+const liveTestStatusSchema = z.enum([
+	"running",
+	"ok",
+	"failed"
+]);
+const runOutcomeSchema = z.enum(["ok", "failed"]);
+const runEndReasonSchema = z.enum(["reported", "stopped"]);
+const testScreenSchema = z.object({
+	deviceId: z.string().min(1),
+	imageBase64: z.string().min(1)
+});
+const testEventSchema = z.object({
+	deviceId: z.string().min(1),
+	testId: z.string().min(1),
+	title: z.string(),
+	specFile: z.string(),
+	status: liveTestStatusSchema,
+	errorLine: z.string().nullable()
+});
+const stepEventSchema = z.object({
+	deviceId: z.string().min(1),
+	testId: z.string().min(1),
+	stepIndex: z.number().int().min(1),
+	stepTitle: z.string(),
+	status: liveTestStatusSchema,
+	errorLine: z.string().nullable()
+});
+const runTotalsSchema = z.object({
+	phase: z.enum(["start", "update"]),
+	totalTests: z.number().int().min(0),
+	startedAt: z.number().int().min(0),
+	endedAt: z.number().int().min(0).nullable(),
+	okCount: z.number().int().min(0),
+	failedCount: z.number().int().min(0),
+	outcome: runOutcomeSchema.nullable(),
+	endReason: runEndReasonSchema.nullable()
+});
+const testsClearSchema = z.object({ deviceIds: z.array(z.string().min(1)) });
+const runSavedSchema = z.object({ runId: z.string().min(1) });
+// src/live/run-silence-logic.ts
+const RUN_SILENCE_LIMIT_MS = 15e3;
+const RUN_STOPPED_LINE = "Run stopped without a report";
+const isRunLive = (runTotals) => runTotals.outcome === null;
+const pickSilentRunEnd = (lastRunTotals, stoppedTestCount, nowMs) => {
+	if (lastRunTotals === null) return null;
+	if (!isRunLive(lastRunTotals)) return null;
+	return {
+		...lastRunTotals,
+		failedCount: lastRunTotals.failedCount + stoppedTestCount,
+		phase: "update",
+		endedAt: nowMs,
+		outcome: "failed",
+		endReason: "stopped"
+	};
+};
+const listStoppedTests = (runningTests) => runningTests.map((runningTest) => ({
+	...runningTest,
+	status: "failed",
+	errorLine: RUN_STOPPED_LINE
+}));
+// src/live/run-watchdog.ts
+const watchdog = { silenceTimer: null };
+const endSilentRun = () => {
+	watchdog.silenceTimer = null;
+	const runningTests = listRunningTests();
+	const silentRunEnd = pickSilentRunEnd(readRunTotals(), runningTests.length, Date.now());
+	if (silentRunEnd === null) return;
+	const stoppedTests = listStoppedTests(runningTests);
+	for (const stoppedTest of stoppedTests) broadcast({
+		kind: "test",
+		...stoppedTest
+	});
+	broadcast({
+		kind: "run-totals",
+		...silentRunEnd
+	});
+};
+const watchRun = (runTotals) => {
+	const { silenceTimer } = watchdog;
+	if (silenceTimer !== null) clearTimeout(silenceTimer);
+	watchdog.silenceTimer = null;
+	if (!isRunLive(runTotals)) return;
+	const nextTimer = setTimeout(endSilentRun, RUN_SILENCE_LIMIT_MS);
+	nextTimer.unref();
+	watchdog.silenceTimer = nextTimer;
+};
+// src/live/live-test-routes.ts
+const NO_CONTENT_STATUS = 204;
+const createLiveTestRoutes = () => new Hono().post("/screens", zValidator("json", testScreenSchema, rejectInvalidRequest), (c) => {
+	const { deviceId, imageBase64 } = c.req.valid("json");
+	broadcast({
+		kind: "screen",
+		deviceId,
+		imageBase64
+	}, "test-run");
+	return c.body(null, NO_CONTENT_STATUS);
+}).post("/events", zValidator("json", testEventSchema, rejectInvalidRequest), (c) => {
+	const testEvent = c.req.valid("json");
+	broadcast({
+		kind: "test",
+		...testEvent
+	});
+	return c.body(null, NO_CONTENT_STATUS);
+}).post("/steps", zValidator("json", stepEventSchema, rejectInvalidRequest), (c) => {
+	const stepEvent = c.req.valid("json");
+	broadcast({
+		kind: "step",
+		...stepEvent
+	});
+	return c.body(null, NO_CONTENT_STATUS);
+}).post("/run", zValidator("json", runTotalsSchema, rejectInvalidRequest), (c) => {
+	const runTotals = c.req.valid("json");
+	broadcast({
+		kind: "run-totals",
+		...runTotals
+	});
+	watchRun(runTotals);
+	return c.body(null, NO_CONTENT_STATUS);
+}).post("/run-saved", zValidator("json", runSavedSchema, rejectInvalidRequest), (c) => {
+	const { runId } = c.req.valid("json");
+	broadcast({
+		kind: "run",
+		runId
+	});
+	return c.body(null, NO_CONTENT_STATUS);
+}).post("/clear", zValidator("json", testsClearSchema, rejectInvalidRequest), (c) => {
+	const { deviceIds } = c.req.valid("json");
+	forgetTests(deviceIds);
+	return c.body(null, NO_CONTENT_STATUS);
+});
+// src/live/zoom-routes.ts
+const zoomSchema = z.object({
+	deviceId: z.string().min(1).nullable(),
+	clientId: z.string().min(1)
+});
+const createZoomRoutes = () => new Hono().put("/", zValidator("json", zoomSchema, rejectInvalidRequest), async (c) => {
+	const { deviceId, clientId } = c.req.valid("json");
+	await changeZoomedDevice(deviceId, clientId);
+	return c.json({ deviceId });
+});
+// src/runs/runs-routes.ts
+const NOT_FOUND_STATUS$2 = 404;
+const CREATED_STATUS = 201;
+const runIdParamSchema = z.object({ runId: z.string().regex(RUN_ID_PATTERN) });
+const newRunSchema = z.object({ origin: runOriginSchema });
+const createRunsRoutes = (rootFolder) => new Hono().get("/", async (c) => {
+	const runs = await listRuns(rootFolder);
+	return c.json(runs);
+}).post("/", zValidator("json", newRunSchema, rejectInvalidRequest), async (c) => {
+	const { origin } = c.req.valid("json");
+	const run = await createRun(rootFolder, origin, "steps");
+	return c.json({ runId: run.runId }, CREATED_STATUS);
+}).get("/:runId", zValidator("param", runIdParamSchema, rejectInvalidRequest), async (c) => {
+	const { runId } = c.req.valid("param");
+	const run = await readRun(rootFolder, runId);
+	if (run === null) throw new HTTPException(NOT_FOUND_STATUS$2, { message: `No run ${runId}` });
+	return c.json(run);
+}).post("/:runId/events", zValidator("param", runIdParamSchema, rejectInvalidRequest), zValidator("json", runEventSchema, rejectInvalidRequest), async (c) => {
+	const { runId } = c.req.valid("param");
+	const runEvent = c.req.valid("json");
+	const savedRun = await saveRunEvent(rootFolder, runId, runEvent);
+	broadcast({
+		kind: "run",
+		runId
+	});
+	return c.json(savedRun);
+});
+// src/runs/shots-routes.ts
+const NOT_FOUND_STATUS$1 = 404;
+const SHOTS_SUBFOLDER = "shots";
+const SHOT_FILE_NAME_PATTERN = /^[A-Za-z0-9-]+\.png$/;
+const SHOT_CONTENT_TYPE = "image/png";
+const shotNameParamSchema = z.object({ fileName: z.string().regex(SHOT_FILE_NAME_PATTERN) });
+const createShotsRoutes = (rootFolder) => new Hono().get("/:fileName", zValidator("param", shotNameParamSchema, rejectInvalidRequest), async (c) => {
+	const { fileName } = c.req.valid("param");
+	const shotPath = join(rootFolder, STORE_FOLDER, SHOTS_SUBFOLDER, fileName);
+	const shotBytes = await readStoredBytes(shotPath);
+	if (shotBytes === null) throw new HTTPException(NOT_FOUND_STATUS$1, { message: `No shot ${fileName}` });
+	const shotImage = new Uint8Array(shotBytes);
+	return c.body(shotImage, 200, { "Content-Type": SHOT_CONTENT_TYPE });
+});
+// src/hub/hub-app.ts
+const createHubApp = (rootFolder, devicePages = [], syncGrid = null) => new Hono().basePath("/api").route("/devices", createDevicesRoutes(rootFolder, syncGrid)).route("/commands", createCommandsRoutes(rootFolder, devicePages)).route("/live-tests", createLiveTestRoutes()).route("/zoom", createZoomRoutes()).route("/runs", createRunsRoutes(rootFolder)).route("/shots", createShotsRoutes(rootFolder)).onError(writeProblem);
+// src/live/live-routes.ts
+const SOCKET_OPEN = 1;
+const CLIENT_ID_QUERY = "clientId";
+const liveRoutes = new Hono().get(LIVE_PATH, upgradeWebSocket((c) => {
+	const clientId = c.req.query(CLIENT_ID_QUERY) ?? null;
+	const unsubscribeBySocket = /* @__PURE__ */ new Map();
+	return {
+		onOpen: (_openEvent, socket) => {
+			const unsubscribe = subscribe((liveMessage) => {
+				if (socket.readyState === SOCKET_OPEN) socket.send(JSON.stringify(liveMessage));
+			});
+			unsubscribeBySocket.set(socket, unsubscribe);
+		},
+		onClose: async (_closeEvent, socket) => {
+			unsubscribeBySocket.get(socket)?.();
+			unsubscribeBySocket.delete(socket);
+			if (!(clientId !== null)) return;
+			try {
+				await releaseClientZoom(clientId);
+			} catch (error) {
+				console.error({
+					clientId,
+					error
+				});
+			}
+		}
+	};
+}));
+// src/hub/hub-server.ts
+const HUB_FILE_MODE = 384;
+const GRID_SYNC_QUEUE_KEY = "grid-sync";
+const NOT_FOUND_STATUS = 404;
+const API_PATH = "/api/*";
+const CLIENT_ROUTE_PATH = "*";
+const INDEX_FILE = "index.html";
+const startGridDevice = async (device) => {
+	const deviceBrowser = await startDeviceBrowser(device);
+	try {
+		return {
+			device,
+			deviceBrowser,
+			devicePage: {
+				device,
+				page: await deviceBrowser.openPage(),
+				hasLiveScreen: deviceBrowser.cdpUrl !== null
+			}
+		};
+	} catch (error) {
+		await deviceBrowser.stop();
+		throw error;
+	}
+};
+const openAppUrlOnDevice = async ({ device, devicePage }, appUrl) => {
+	try {
+		await devicePage.page.goto(appUrl);
+	} catch (error) {
+		console.error({
+			deviceId: device.id,
+			error
+		});
+	}
+};
+const openAppUrlOnDevices = async (gridDevices, appUrl) => {
+	if (appUrl === null) return;
+	const openingDevices = gridDevices.map((gridDevice) => openAppUrlOnDevice(gridDevice, appUrl));
+	await Promise.all(openingDevices);
+};
+const stopGridDevices = async (gridDevices) => {
+	const stopReplies = await Promise.allSettled(gridDevices.map(({ deviceBrowser }) => deviceBrowser.stop()));
+	for (const stopReply of stopReplies) if (stopReply.status === "rejected") console.error({ error: stopReply.reason });
+};
+const startGridDevices = async (devices) => {
+	const startReplies = await Promise.allSettled(devices.map(startGridDevice));
+	const startedDevices = startReplies.filter((startReply) => startReply.status === "fulfilled").map((startReply) => startReply.value);
+	const failedStart = startReplies.find((startReply) => startReply.status === "rejected");
+	if (failedStart !== void 0) {
+		await stopGridDevices(startedDevices);
+		throw new Error("A device browser failed to start", { cause: failedStart.reason });
+	}
+	return startedDevices;
+};
+const createHubFile = (port, gridDevices) => ({
+	pid: process.pid,
+	port,
+	devices: Object.fromEntries(gridDevices.map(({ device, deviceBrowser }) => [device.id, {
+		wsEndpoint: deviceBrowser.wsEndpoint,
+		cdpUrl: deviceBrowser.cdpUrl
+	}]))
+});
+const writeHubFile = async (hubFilePath, hubFile) => {
+	const serializedHubFile = JSON.stringify(hubFile, null, 2);
+	await writeStoredFile(hubFilePath, serializedHubFile, HUB_FILE_MODE);
+};
+const removeFromList = (list, isRemoved) => {
+	const keptEntries = list.filter((listed) => !isRemoved(listed));
+	list.splice(0, list.length, ...keptEntries);
+};
+const createGridSync = (gridDevices, devicePages, writeCurrentHubFile) => (nextDevices) => runOneAtATime(GRID_SYNC_QUEUE_KEY, async () => {
+	const pageUrls = devicePages.map(({ page }) => page.url());
+	const { appUrl } = pickOpenApp(pageUrls);
+	const runningDeviceIds = gridDevices.map(({ device }) => device.id);
+	const { addDevices, removeDeviceIds } = pickGridChanges(runningDeviceIds, nextDevices);
+	const goneDevices = gridDevices.filter(({ device }) => removeDeviceIds.includes(device.id));
+	removeFromList(gridDevices, ({ device }) => removeDeviceIds.includes(device.id));
+	removeFromList(devicePages, ({ device }) => removeDeviceIds.includes(device.id));
+	await stopGridDevices(goneDevices);
+	for (const removeDeviceId of removeDeviceIds) forgetDeviceScreen(removeDeviceId);
+	const startedDevices = await startGridDevices(addDevices);
+	gridDevices.push(...startedDevices);
+	devicePages.push(...startedDevices.map(({ devicePage }) => devicePage));
+	await openAppUrlOnDevices(startedDevices, appUrl);
+	await writeCurrentHubFile();
+	broadcast({ kind: "device-list" });
+});
+const createHubServerApp = (hubStart, devicePages, syncGrid) => {
+	const { rootFolder, dashboardFolder } = hubStart;
+	return new Hono().route("/", createHubApp(rootFolder, devicePages, syncGrid)).route("/", liveRoutes).all(API_PATH, () => {
+		throw new HTTPException(NOT_FOUND_STATUS, { message: "No such route" });
+	}).use(CLIENT_ROUTE_PATH, serveStatic({ root: dashboardFolder })).get(CLIENT_ROUTE_PATH, serveStatic({
+		root: dashboardFolder,
+		path: INDEX_FILE
+	})).onError(writeProblem);
+};
+const listen = (hubServerApp, websocketServer, port) => new Promise((onListening, onListenFailed) => {
+	const httpServer = serve({
+		fetch: hubServerApp.fetch,
+		port,
+		hostname: HUB_HOST,
+		websocket: { server: websocketServer }
+	}, (addressInfo) => onListening({
+		httpServer,
+		port: addressInfo.port
+	}));
+	httpServer.once("error", onListenFailed);
+});
+const closeServer = (httpServer) => new Promise((onClosed, onCloseFailed) => {
+	httpServer.close((error) => {
+		if (error !== void 0) onCloseFailed(error);
+		else onClosed();
+	});
+	if ("closeAllConnections" in httpServer) httpServer.closeAllConnections();
+});
+const listenOrStopDevices = async (hubServerApp, websocketServer, port, gridDevices) => {
+	try {
+		return await listen(hubServerApp, websocketServer, port);
+	} catch (error) {
+		await stopGridDevices(gridDevices);
+		throw error;
+	}
+};
+const startHub = async (hubStart) => {
+	const { rootFolder, port } = hubStart;
+	await closeLeftOpenRuns(rootFolder);
+	const devicesFile = await readDevicesFile(rootFolder);
+	const gridDevices = await startGridDevices(pickGridDevices(devicesFile));
+	const devicePages = gridDevices.map(({ devicePage }) => devicePage);
+	const hubFilePath = join(rootFolder, HUB_FILE_PATH);
+	const websocketServer = new WebSocketServer({ noServer: true });
+	const writeCurrentHubFile = () => writeHubFile(hubFilePath, createHubFile(listeningServer.port, gridDevices));
+	const syncGrid = createGridSync(gridDevices, devicePages, writeCurrentHubFile);
+	const hubServerApp = createHubServerApp(hubStart, devicePages, syncGrid);
+	const listeningServer = await listenOrStopDevices(hubServerApp, websocketServer, port, gridDevices);
+	try {
+		await writeCurrentHubFile();
+		const stop = async () => {
+			await rm(hubFilePath, { force: true });
+			for (const liveClient of websocketServer.clients) liveClient.terminate();
+			await closeServer(listeningServer.httpServer);
+			try {
+				await closeInteractiveRun(rootFolder);
+			} finally {
+				await stopGridDevices(gridDevices);
+			}
+		};
+		return {
+			url: `http://${HUB_HOST}:${listeningServer.port}`,
+			stop
+		};
+	} catch (error) {
+		await closeServer(listeningServer.httpServer);
+		await stopGridDevices(gridDevices);
+		throw error;
+	}
+};
+// src/cli/hub-process.ts
+const HUB_LOG_PATH = `${STORE_FOLDER}/hub.log`;
+const START_TIMEOUT_MS = 18e4;
+const STOP_TIMEOUT_MS = 3e4;
+const POLL_INTERVAL_MS = 200;
+const DASHBOARD_PATH = import.meta.url.endsWith(".mjs") ? "./dashboard" : "../../dist/dashboard";
+const dashboardUrl = new URL(DASHBOARD_PATH, import.meta.url);
+const DASHBOARD_FOLDER = fileURLToPath(dashboardUrl);
+const isProcessMissingError = (error) => error instanceof Error && "code" in error && error.code === "ESRCH";
+const isProcessAlive = (processId) => {
+	try {
+		process.kill(processId, 0);
+		return true;
+	} catch (error) {
+		if (isProcessMissingError(error)) return false;
+		throw error;
+	}
+};
+const sendStopSignal = (processId) => {
+	try {
+		process.kill(processId, "SIGTERM");
+	} catch (error) {
+		if (isProcessMissingError(error)) return;
+		throw error;
+	}
+};
+const removeHubFile = async (rootFolder) => {
+	const hubFilePath = join(rootFolder, HUB_FILE_PATH);
+	await rm(hubFilePath, { force: true });
+};
+const waitForHubFile = async (rootFolder, hubProcessId) => {
+	const giveUpAt = Date.now() + START_TIMEOUT_MS;
+	const isBeforeDeadline = () => Date.now() < giveUpAt;
+	while (isBeforeDeadline()) {
+		const hubFile = await readHubFile(rootFolder);
+		if (hubFile !== null && hubFile.pid === hubProcessId) return hubFile;
+		if (!isProcessAlive(hubProcessId)) return null;
+		await setTimeout$1(POLL_INTERVAL_MS);
+	}
+	return null;
+};
+const spawnHubProcess = async (rootFolder, port) => {
+	const storeFolder = join(rootFolder, STORE_FOLDER);
+	const hubLogPath = join(rootFolder, HUB_LOG_PATH);
+	await mkdir(storeFolder, { recursive: true });
+	const hubLog = await open(hubLogPath, "a");
+	const [, cliPath] = process.argv;
+	const hubProcess = spawn(process.execPath, [
+		...process.execArgv,
+		cliPath,
+		"start",
+		"--foreground",
+		"--port",
+		String(port)
+	], {
+		cwd: rootFolder,
+		detached: true,
+		stdio: [
+			"ignore",
+			hubLog.fd,
+			hubLog.fd
+		]
+	});
+	try {
+		await once(hubProcess, "spawn");
+	} finally {
+		await hubLog.close();
+	}
+	hubProcess.unref();
+	const hubProcessId = hubProcess.pid;
+	if (hubProcessId === void 0) throw new Error("The hub process did not start");
+	return hubProcessId;
+};
+const checkRunningHub = async (rootFolder, requestedPort) => {
+	const oldHubFile = await readHubFile(rootFolder);
+	if (!(oldHubFile !== null && await isHubAnswering(oldHubFile))) return null;
+	const oldHubUrl = createHubUrl(oldHubFile);
+	if (isPortConflict(requestedPort, oldHubFile.port)) return createPortConflictReply(oldHubUrl);
+	const oldDeviceCount = countDevices(oldHubFile);
+	const runningLine = createRunningLine(oldHubUrl, oldDeviceCount);
+	return createReply("ok", runningLine);
+};
+const startHubInBackground = async (rootFolder, requestedPort) => {
+	const runningHubReply = await checkRunningHub(rootFolder, requestedPort);
+	if (runningHubReply !== null) return runningHubReply;
+	await removeHubFile(rootFolder);
+	const hubProcessId = await spawnHubProcess(rootFolder, requestedPort ?? 4100);
+	const hubFile = await waitForHubFile(rootFolder, hubProcessId);
+	if (hubFile === null) {
+		sendStopSignal(hubProcessId);
+		return createReply("failed", `hub did not start · see ${HUB_LOG_PATH}`);
+	}
+	const hubUrl = createHubUrl(hubFile);
+	const deviceCount = countDevices(hubFile);
+	const readyLine = createReadyLine(hubUrl, deviceCount);
+	return createReply("ok", readyLine);
+};
+const waitForStopSignal = async () => {
+	const termSignal = once(process, "SIGTERM");
+	const interruptSignal = once(process, "SIGINT");
+	await Promise.race([termSignal, interruptSignal]);
+};
+const stopRunningHub = async (runningHub) => {
+	try {
+		await runningHub.stop();
+	} catch (error) {
+		console.error({ error });
+		return createReply("failed", "hub did not stop cleanly");
+	}
+	return createReply("ok", "hub stopped");
+};
+const startHubInForeground = async (rootFolder, requestedPort, writeStartedReply) => {
+	const runningHubReply = await checkRunningHub(rootFolder, requestedPort);
+	if (runningHubReply !== null) return runningHubReply;
+	const stopSignal = waitForStopSignal();
+	const runningHub = await startHub({
+		rootFolder,
+		port: requestedPort ?? 4100,
+		dashboardFolder: DASHBOARD_FOLDER
+	});
+	const hubFile = await readHubFile(rootFolder);
+	if (hubFile === null) {
+		await runningHub.stop();
+		throw new Error("The hub did not write its hub file");
+	}
+	const deviceCount = countDevices(hubFile);
+	const readyLine = createReadyLine(runningHub.url, deviceCount);
+	writeStartedReply(createReply("ok", readyLine));
+	await stopSignal;
+	return stopRunningHub(runningHub);
+};
+const stopHub = async (rootFolder) => {
+	const hubFile = await readHubFile(rootFolder);
+	if (hubFile === null) return createHubDownReply();
+	if (!await isHubAnswering(hubFile)) {
+		await removeHubFile(rootFolder);
+		return createHubDownReply();
+	}
+	sendStopSignal(hubFile.pid);
+	const giveUpAt = Date.now() + STOP_TIMEOUT_MS;
+	const isWaitingForExit = () => isProcessAlive(hubFile.pid) && Date.now() < giveUpAt;
+	while (isWaitingForExit()) await setTimeout$1(POLL_INTERVAL_MS);
+	if (isProcessAlive(hubFile.pid)) return createReply("failed", `hub did not stop · pid ${hubFile.pid}`);
+	return createReply("ok", "hub stopped");
+};
+// src/flows/flow-schema.ts
+const STEP_WITHOUT_COMMAND_FIELDS = {
+	commandName: true,
+	deviceIds: true
+};
+const flowStepSchema = z.union([
+	z.strictObject({ open: openCommandSchema.shape.url }).transform(({ open }) => ({
+		commandName: "open",
+		url: open
+	})),
+	z.strictObject({ tap: tapCommandSchema.omit(STEP_WITHOUT_COMMAND_FIELDS).strict() }).transform(({ tap }) => ({
+		commandName: "tap",
+		...tap
+	})),
+	z.strictObject({ fill: fillCommandSchema.omit(STEP_WITHOUT_COMMAND_FIELDS).strict() }).transform(({ fill }) => ({
+		commandName: "fill",
+		...fill
+	})),
+	z.strictObject({ scroll: scrollCommandSchema.omit(STEP_WITHOUT_COMMAND_FIELDS).strict() }).transform(({ scroll }) => ({
+		commandName: "scroll",
+		...scroll
+	})),
+	z.strictObject({ expect: expectCommandSchema.omit(STEP_WITHOUT_COMMAND_FIELDS).strict() }).transform(({ expect }) => ({
+		commandName: "expect",
+		...expect
+	})),
+	z.strictObject({ check: z.null() }).transform(() => ({ commandName: "check" })),
+	z.strictObject({ shot: z.null() }).transform(() => ({ commandName: "shot" }))
+]);
+const flowSchema = z.strictObject({
+	name: z.string(),
+	devices: z.array(z.string()).min(1).nullable().default(null),
+	steps: z.array(flowStepSchema)
+});
+z.number().int().min(1);
+// src/flows/flow-runner.ts
+const listFlowPaths = async (rootFolder, flowsGlob) => {
+	const flowPaths = [];
+	for await (const flowPath of glob(flowsGlob, { cwd: rootFolder })) flowPaths.push(flowPath);
+	return flowPaths.toSorted();
+};
+const readFlow = async (rootFolder, flowPath) => {
+	const flowYaml = await readFile(join(rootFolder, flowPath), "utf8");
+	const flowDocument = parse(flowYaml);
+	const flowCheck = flowSchema.safeParse(flowDocument);
+	if (flowCheck.success) return flowCheck.data;
+	const [firstIssue] = flowCheck.error.issues;
+	const badField = firstIssue.path.join(".");
+	throw new Error(`${flowPath} is not a valid flow: ${badField !== "" ? badField : "file"}: ${firstIssue.message}`, { cause: flowCheck.error });
+};
+const runFlow = async (rootFolder, flowPath) => {
+	const flow = await readFlow(rootFolder, flowPath);
+	const stepReplies = [];
+	for (const hubCommand of listFlowCommands(flow)) {
+		const stepReply = await sendHubCommand(rootFolder, hubCommand);
+		stepReplies.push(stepReply);
+		if (stepReply.status === "failed") break;
+	}
+	return createFlowAnswer(flowPath, stepReplies);
+};
+const runFlowOrFail = async (rootFolder, flowPath) => {
+	try {
+		return await runFlow(rootFolder, flowPath);
+	} catch (error) {
+		const problemLine = error instanceof Error ? error.message : "the flow did not run";
+		return createFailedFlowAnswer(flowPath, problemLine);
+	}
+};
+const runFlows = async (rootFolder, flowPaths, parallel) => {
+	const flowAnswers = [];
+	for (const flowBatch of listFlowBatches(flowPaths, parallel)) {
+		const batchAnswers = await Promise.all(flowBatch.map((flowPath) => runFlowOrFail(rootFolder, flowPath)));
+		flowAnswers.push(...batchAnswers);
+	}
+	return flowAnswers;
+};
+// src/skill/skill-install.ts
+const SKILL_FOLDERS = {
+	claude: ".claude/skills/everyscreen",
+	codex: ".agents/skills/everyscreen",
+	cursor: ".cursor/skills/everyscreen"
+};
+const SKILL_FILE_URLS = [new URL("./SKILL.md", import.meta.url), new URL("../src/skill/SKILL.md", import.meta.url)];
+const readSkillMarkdown = async () => {
+	for (const skillFileUrl of SKILL_FILE_URLS) {
+		const skillPath = fileURLToPath(skillFileUrl);
+		const skillMarkdown = await readStoredFile(skillPath);
+		if (skillMarkdown !== null) return skillMarkdown;
+	}
+	throw new Error("SKILL.md is missing from the Everyscreen package");
+};
+const pickSkillFile = (agent, rootFolder) => join(rootFolder, SKILL_FOLDERS[agent], "SKILL.md");
+const installSkill = async (agent, rootFolder) => {
+	const installedFile = pickSkillFile(agent, rootFolder);
+	const skillMarkdown = await readSkillMarkdown();
+	await writeStoredFile(installedFile, skillMarkdown);
+	return installedFile;
+};
+// src/cli/cli-requests.ts
+const listHubDevices = (rootFolder, createDevicesReply) => callHub(rootFolder, async (hubClient, hubUrl) => {
+	const devicesReply = await hubClient.api.devices.$get();
+	if (!devicesReply.ok) return readProblemReply(devicesReply);
+	return createDevicesReply(await devicesReply.json(), hubUrl);
+});
+const showHubStatus = (rootFolder) => listHubDevices(rootFolder, (hubDevices, hubUrl) => {
+	const runningLine = createRunningLine(hubUrl, hubDevices.length);
+	return createReply("ok", runningLine);
+});
+const listDevices = (rootFolder) => listHubDevices(rootFolder, (hubDevices) => {
+	const deviceIds = hubDevices.map(({ id }) => id);
+	const deviceListLine = createDeviceListLine(deviceIds);
+	return createReply("ok", deviceListLine);
+});
+const addDevice = (rootFolder, customDevice) => callHub(rootFolder, async (hubClient) => {
+	const addReply = await hubClient.api.devices.$post({ json: customDevice });
+	if (!addReply.ok) return readProblemReply(addReply);
+	const devicePreset = await addReply.json();
+	return createReply("ok", `device added · ${devicePreset.id}`);
+});
+const removeDevice = (rootFolder, deviceId) => callHub(rootFolder, async (hubClient) => {
+	const removeReply = await hubClient.api.devices[":deviceId"].$delete({ param: { deviceId } });
+	if (!removeReply.ok) return readProblemReply(removeReply);
+	return createReply("ok", `device removed · ${deviceId}`);
+});
+const runFlowFiles = async (rootFolder, flowsGlob, parallel) => {
+	const flowPaths = await listFlowPaths(rootFolder, flowsGlob);
+	if (flowPaths.length === 0) throw new HTTPException(400, { message: `no flow file matches ${flowsGlob}` });
+	if (await readHubFile(rootFolder) === null) return createHubDownReply();
+	const flowAnswers = await runFlows(rootFolder, flowPaths, parallel);
+	return summarizeFlows(flowAnswers);
+};
+const readBeforeSteps = async (rootFolder, beforeFlowPath) => {
+	try {
+		const beforeFlow = await readFlow(rootFolder, beforeFlowPath);
+		return listFlowCommands(beforeFlow);
+	} catch (error) {
+		const errorLine = pickErrorMessage(error);
+		return createReply("failed", `before flow: ${errorLine}`);
+	}
+};
+const sweepApp = async (rootFolder, sweepCommand, beforeFlowPath) => {
+	if (beforeFlowPath === null) return sendHubCommand(rootFolder, sweepCommand);
+	const beforeStepsReply = await readBeforeSteps(rootFolder, beforeFlowPath);
+	if (!Array.isArray(beforeStepsReply)) return beforeStepsReply;
+	return sendHubCommand(rootFolder, {
+		...sweepCommand,
+		beforeSteps: beforeStepsReply
+	});
+};
+const installAgentSkill = async (rootFolder, agent, isConfirmed) => {
+	const skillFile = pickSkillFile(agent, rootFolder);
+	if (await readStoredFile(skillFile) !== null && !isConfirmed) throw new HTTPException(400, { message: "skill install needs --yes to replace the skill already installed" });
+	const installedFile = await installSkill(agent, rootFolder);
+	return createReply("ok", `skill installed · ${installedFile}`);
+};
+const runCliRequest = (cliRequest, rootFolder, writeStartedReply) => {
+	switch (cliRequest.kind) {
+		case "send-command": return sendHubCommand(rootFolder, cliRequest.hubCommand);
+		case "start": {
+			const { port, isForeground } = cliRequest;
+			if (isForeground) return startHubInForeground(rootFolder, port, writeStartedReply);
+			return startHubInBackground(rootFolder, port);
+		}
+		case "stop": return stopHub(rootFolder);
+		case "status": return showHubStatus(rootFolder);
+		case "list-devices": return listDevices(rootFolder);
+		case "add-device": return addDevice(rootFolder, cliRequest.customDevice);
+		case "remove-device": return removeDevice(rootFolder, cliRequest.deviceId);
+		case "run-flows": return runFlowFiles(rootFolder, cliRequest.flowsGlob, cliRequest.parallel);
+		case "run-sweep": return sweepApp(rootFolder, cliRequest.sweepCommand, cliRequest.beforeFlowPath);
+		case "install-skill": return installAgentSkill(rootFolder, cliRequest.agent, cliRequest.isConfirmed);
+	}
+};
+// src/cli/cli.ts
+const EXIT_CODES = {
+	ok: 0,
+	failed: 1,
+	badUsage: 2
+};
+const runPlan = async (cliPlan, isJsonWanted) => {
+	switch (cliPlan.kind) {
+		case "show-help": {
+			const helpReply = createReply("ok", cliPlan.helpPage);
+			writeReply(helpReply, isJsonWanted);
+			return EXIT_CODES.ok;
+		}
+		case "bad-usage": {
+			const badUsageReply = createReply("failed", cliPlan.message);
+			writeReply(badUsageReply, isJsonWanted);
+			return EXIT_CODES.badUsage;
+		}
+		case "run": {
+			const writeStartedReply = (startedReply) => writeReply(startedReply, isJsonWanted);
+			const commandReply = await runCliRequest(cliPlan.cliRequest, process.cwd(), writeStartedReply);
+			const isTerminal = process.stdout.isTTY === true;
+			if (canWriteFinalReply(cliPlan.cliRequest, isJsonWanted, isTerminal)) writeReply(commandReply, isJsonWanted);
+			return EXIT_CODES[commandReply.status];
+		}
+	}
+};
+const runCli = async () => {
+	const commandLineWords = process.argv.slice(2);
+	const isJsonWanted = commandLineWords.includes("--json");
+	const commandLine = readCommandLine(commandLineWords);
+	if (commandLine.kind === "unreadable") {
+		const unreadableReply = createReply("failed", commandLine.message);
+		writeReply(unreadableReply, isJsonWanted);
+		process.exitCode = EXIT_CODES.badUsage;
+		return;
+	}
+	const isTerminal = process.stdout.isTTY === true;
+	const cliPlan = planCli(commandLine.commandWords, commandLine.flags, isTerminal);
+	try {
+		process.exitCode = await runPlan(cliPlan, isJsonWanted);
+	} catch (error) {
+		const badUsageDetail = pickBadUsageDetail(error);
+		if (badUsageDetail !== null) {
+			const badUsageReply = createReply("failed", createBadUsageLine(badUsageDetail));
+			writeReply(badUsageReply, isJsonWanted);
+			process.exitCode = EXIT_CODES.badUsage;
+			return;
+		}
+		console.error({ error });
+		const errorLine = error instanceof Error ? error.message : "unexpected error";
+		const errorReply = createReply("failed", errorLine);
+		writeReply(errorReply, isJsonWanted);
+		process.exitCode = EXIT_CODES.failed;
+	}
+};
+await runCli();
+export {};