playthrough 0.1.0 → 0.3.0

package/src/{read-BBNVC-oH.js → flows-Dt7fcPLt.js}

@@ -1,465 +1,14 @@
-import { d as firstLine, f as glimpsesOf, p as readingsOf } from "./reporter-Biym3TnN.js";
+import { O as list, b as Refused, g as readingsOf, k as quote, m as glimpsesOf, p as firstLine, x as Reviews } from "./reporter-4C_7joIm.js";
+import * as modules from "node:module";
 import { createRequire } from "node:module";
 import { existsSync, watch } from "node:fs";
-import { z } from "zod";
 import { spawn } from "node:child_process";
-import { tmpdir } from "node:os";
+import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { constants, tmpdir } from "node:os";
 import { dirname, join, relative } from "node:path";
-import { mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { chromium, request } from "@playwright/test";
 import { createHash, randomUUID } from "node:crypto";
-// ../review/src/model.ts
-const text = (error) => z.string({ error }).refine((value) => value.trim() !== "", { error });
-const seconds = (error) => z.number({ error }).min(0, { error });
-const share = (error) => z.number({ error }).min(0, { error }).max(1, { error });
-const fileName = (error) => z.string({ error }).regex(/^[\w.-]+(\/[\w.-]+)*$/, { error }).refine((name) => !name.split("/").some((part) => part === "." || part === ".."), { error });
-const Element$1 = z.strictObject({
-	role: text("needs its role").describe("As getByRole takes it, or text, row or box for something with no role of its own"),
-	name: text("needs its name"),
-	css: z.string().optional(),
-	node: z.number().int().optional().describe("The element in that round's recording")
-});
-const onScreen$1 = "isn't on the screen. Boxes and points are shares of the screen, from 0 to 1";
-const Box = z.strictObject({
-	x: share(onScreen$1),
-	y: share(onScreen$1),
-	width: share(onScreen$1),
-	height: share(onScreen$1)
-}).refine((box) => box.x + box.width <= 1 && box.y + box.height <= 1, { error: onScreen$1 });
-const Point = z.strictObject({
-	x: share(onScreen$1),
-	y: share(onScreen$1)
-});
-const Did = z.strictObject({
-	does: text("needs what it did"),
-	on: text("needs the path to what it was done on"),
-	with: z.union([
-		z.string(),
-		z.boolean(),
-		z.array(z.string())
-	]).optional(),
-	what: z.string().optional().describe("The words of what it was done on")
-});
-const Place = z.strictObject({
-	flow: text("needs the flow it's on"),
-	at: seconds("needs its moment, in seconds").optional().describe("Without it, the whole flow"),
-	until: seconds("needs its end, in seconds").optional().describe("The end of a stretch"),
-	element: Element$1.optional(),
-	alike: z.array(Element$1).optional().describe("The other things changed alike with its element, each where it is"),
-	box: Box.optional().describe("Something with no words of its own, or where only the pixels changed"),
-	point: Point.optional().describe("Empty space"),
-	app: z.strictObject({
-		from: z.strictObject({
-			flow: text("needs the flow it was taken over in"),
-			at: seconds("needs the moment it was taken over at, in seconds")
-		}),
-		did: z.array(Did).describe("What the person did there, in order"),
-		recording: fileName("needs its recording: the name of a file in the round").describe("The flow up to where it was taken over, then the person's own steps"),
-		length: z.number({ error: "needs its length, in seconds" }).positive({ error: "needs its length, in seconds" })
-	}).optional().describe("In the app: on the person's own recording, which branches off a flow where they took it over. Its flow names the branch")
-}).refine((place) => [
-	place.element,
-	place.box,
-	place.point
-].filter((thing) => thing).length <= 1, { error: "is on more than one thing. Choose an element, a box or a point" }).refine((place) => place.at !== void 0 || !(place.element || place.box || place.point), { error: "is on something but at no moment. Give it one" }).refine((place) => place.until === void 0 || place.at !== void 0 && place.until > place.at, { error: "ends before it starts. A stretch ends after its moment" });
-const Step = z.strictObject({
-	title: text("needs a title").describe("Steps are matched across rounds by their title"),
-	at: seconds("needs the moment it starts, in seconds"),
-	actions: z.array(seconds("needs the moment each of its actions was done, in seconds")).optional().describe("When each of its actions was done: between them the page rests, and a person can take the flow over there"),
-	person: text("needs the name of who does it, or no person").optional().describe("Who does it, once the flow has changed hands: someone other than who the flow is done as")
-});
-const Flow = z.strictObject({
-	name: text("needs a name").describe("Its identity: a new name is a new flow"),
-	length: z.number({ error: "needs its length, in seconds" }).positive({ error: "needs its length, in seconds" }),
-	steps: z.array(Step),
-	recording: fileName("needs its recording: the name of a file in the round"),
-	line: text("needs words in its line, or no line").optional().describe("The agent's, at the flow's start: what it starts from, or the choice it shows"),
-	stopped: text("needs the step it stopped at").optional().describe("On Before, the step the flow couldn't take there: it's kept as far as that, and tried again by playthrough start"),
-	person: text("needs the name of who it acts as, or no person").optional().describe("Who the flow is done as, as its file or the app's setup names them: the name on the recorded pointer, handed to you when you take over"),
-	unsteady: z.array(text("needs the ids of the changes it makes by itself")).optional().describe("Changes found between two recordings of the same app, like a time the server stamps: left out of every comparison, in every flow")
-});
-const Change = z.strictObject({
-	id: text("needs an id").describe("Its thing and its kind of change, so it keeps its id in every round while it's the same change"),
-	words: text("needs its words").describe("What changed, for the agent: “Download CSV and Cancel have swapped places”"),
-	seen: z.array(Place, { error: "needs where it's seen, a list" }).min(1, { error: "needs where it's seen: each flow, at its moment there" }).describe("Each flow it's seen in, at its moment there; a flow that's gone, with no moment")
-});
-const Comparison = z.strictObject({
-	round: z.number({ error: "needs its round" }).int().min(1, { error: "needs its round, after Before" }),
-	since: z.number({ error: "needs the round it's compared with" }).int().min(0).describe("0 is Before"),
-	changes: z.array(Change, { error: "needs its changes, a list, even if it's empty" })
-});
-const Account = z.union([
-	z.strictObject({ line: text("needs words in its line") }).describe("Why it's there, in the agent's voice: what it meant or chose"),
-	z.strictObject({ note: text("needs the note it was made for") }).describe("Made for that note: the reply on the note says why"),
-	z.strictObject({ notReal: text("needs to say why nothing really changed") }).describe("Nothing really changed; nobody is shown it")
-], { error: "says one of { line }, { note } or { notReal }" });
-const Reply = z.strictObject({
-	note: text("needs the note it answers"),
-	words: z.string({ error: "needs its words, even if empty until it's answered" }),
-	on: Place.optional().describe("Where it shows on this round's recording; without it, the note's place was lost"),
-	watch: text("needs a step's title").optional().describe("For an answer that moves: the step of its flow it's seen in, which the note then plays")
-});
-const Note = z.strictObject({
-	id: text("needs an id"),
-	on: Place.optional().describe("Without it, about the work in general"),
-	words: text("needs words")
-});
-const Round = z.strictObject({
-	number: z.number().int().min(0).describe("Round 0 is Before: the app as it was"),
-	by: text("needs to say which agent recorded it").describe("By the name it goes by, “Claude Code” or “Codex”: one review can pass between agents"),
-	flows: z.array(Flow),
-	replies: z.array(Reply).describe("The agent's answer to each note that asks for one"),
-	accounts: z.record(z.string(), Account).describe("What the agent says about each change new since the round before, by its id"),
-	commit: z.string().optional().describe("What it was recorded from"),
-	cantStart: z.array(text("needs the flow's name")).optional().describe("Before: the flows the app as it was can't start, so they have no Before"),
-	finished: z.iso.datetime().optional()
-});
-const Verdict = z.strictObject({
-	note: text("needs the note it's on"),
-	verdict: z.enum(["looks good", "not quite"], { error: "is “looks good” or “not quite”" }),
-	words: z.string().optional()
-}).refine((verdict) => verdict.verdict !== "not quite" || verdict.words?.trim(), { error: "is not quite, so it needs words saying what's still wrong" });
-const Send = z.strictObject({
-	id: text("needs an id").describe("Chosen by the sender, so sending twice sends once"),
-	round: z.number().int().min(0),
-	by: text("needs to say who sent it"),
-	sent: z.iso.datetime({ error: "needs to say when it was sent, as an ISO date" }),
-	notes: z.array(Note).describe("New ones"),
-	verdicts: z.array(Verdict),
-	looksGood: z.array(text("needs the flow's name")).describe("Flows that look good as a whole; one that isn't quite right gets a note"),
-	takenBack: z.array(text("needs the flow's name")).optional().describe("Flows whose Looks good, said before, is taken back: they ask again")
-});
-const Taken = z.strictObject({
-	send: z.string(),
-	round: z.number().int(),
-	at: z.iso.datetime()
-});
-const Accepted = z.strictObject({
-	by: z.string(),
-	at: z.iso.datetime()
-});
-z.strictObject({
-	id: z.string(),
-	title: z.string().describe("A few words for the change, as a pull request's title"),
-	asked: z.string().optional().describe("What was asked, in the person's words"),
-	started: z.iso.datetime(),
-	rounds: z.array(Round),
-	comparisons: z.array(Comparison),
-	sends: z.array(Send),
-	taken: z.array(Taken),
-	accepted: Accepted.optional()
-});
-// ../review/src/words.ts
-const list = (things) => things.length > 1 ? `${things.slice(0, -1).join(", ")} and ${things.at(-1)}` : things[0] ?? "";
-const time = (seconds) => `${Math.floor(seconds / 60)}:${String(Math.floor(seconds % 60)).padStart(2, "0")}`;
-const quote = (name) => `“${name}”`;
-// ../review/src/rules.ts
-function roundInProgress(review) {
-	const last = review.rounds.at(-1);
-	if (!last) return 0;
-	return last.finished ? last.number + 1 : last.number;
-}
-function allNotes(review) {
-	const notes = /* @__PURE__ */ new Map();
-	for (const send of review.sends) for (const note of send.notes) notes.set(note.id, {
-		note,
-		round: send.round,
-		by: send.by
-	});
-	return notes;
-}
-function lastSeen(review, id, before) {
-	const started = allNotes(review).get(id);
-	if (!started?.note.on) return void 0;
-	const placed = review.rounds.findLast((round) => round.number > started.round && round.number < before && round.replies.some((reply) => reply.note === id && reply.on));
-	const on = placed?.replies.find((reply) => reply.note === id)?.on;
-	return placed && on ? {
-		round: placed.number,
-		on
-	} : {
-		round: started.round,
-		on: started.note.on
-	};
-}
-function conversation(review, id) {
-	const started = allNotes(review).get(id);
-	if (!started) return [];
-	const turns = [{
-		turn: {
-			by: started.by,
-			agent: false,
-			round: started.round,
-			words: started.note.words
-		},
-		order: 0
-	}];
-	for (const round of review.rounds.filter((round) => round.number > started.round)) {
-		const reply = round.replies.find((reply) => reply.note === id);
-		if (reply?.words.trim()) turns.push({
-			turn: {
-				by: round.by,
-				agent: true,
-				round: round.number,
-				words: reply.words
-			},
-			order: 1
-		});
-	}
-	for (const send of review.sends) for (const verdict of send.verdicts.filter((verdict) => verdict.note === id)) turns.push({
-		turn: {
-			by: send.by,
-			agent: false,
-			round: send.round,
-			words: verdict.words ?? "",
-			verdict: verdict.verdict
-		},
-		order: 2
-	});
-	return turns.sort((a, b) => a.turn.round - b.turn.round || a.order - b.order).map(({ turn }) => turn);
-}
-function notesToAnswer(review, round) {
-	return asking(review.sends.filter((send) => review.taken.some((taken) => taken.send === send.id && taken.round === round)));
-}
-function waitingForTheAgent(review) {
-	const answered = (send) => {
-		const taken = review.taken.find((taken) => taken.send === send.id);
-		return !!taken && review.rounds.some((round) => round.number === taken.round && round.finished);
-	};
-	return asking(review.sends.filter((send) => !answered(send)));
-}
-function asking(sends) {
-	const asks = /* @__PURE__ */ new Set();
-	const last = /* @__PURE__ */ new Map();
-	for (const send of sends) {
-		for (const note of send.notes) asks.add(note.id);
-		for (const verdict of send.verdicts) last.set(verdict.note, verdict.verdict);
-	}
-	for (const [note, verdict] of last) if (verdict === "not quite") asks.add(note);
-	return [...asks];
-}
-function problemsWithId(id) {
-	return typeof id === "string" && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(id) ? [] : [`A review's id is lowercase words joined by dashes, like “export-a-quarter”, not “${id}”.`];
-}
-function problemsStarting(id, title, asked) {
-	const problems = problemsWithId(id);
-	if (!isText$1(title)) problems.push("A review needs a title: a few words for the change, as a pull request's title.");
-	if (asked !== void 0 && !isText$1(asked)) problems.push("What was asked is the person's words, as they put it.");
-	return problems;
-}
-function problemsWithRound(review, round) {
-	const shape = problemsWithShape(Round, round, Number.isInteger(round?.number) ? `Round ${round.number}` : "This round");
-	if (shape.length) return shape;
-	if (review.accepted) return ["This review is accepted, so nothing more can be recorded."];
-	const due = roundInProgress(review);
-	if (round.number !== due && !(review.rounds.length === 0 && round.number === 1)) {
-		if (review.rounds.length === 0) return ["The first round is 0, Before, or 1 when the app is new and there's no Before."];
-		if (round.number < due) return [`Round ${round.number} is finished, so it can't change.`];
-		return [`Round ${round.number} can't be recorded yet: the round being worked on is ${due}.`];
-	}
-	const at = `Round ${round.number}`;
-	const problems = problemsWithFlows(round, at);
-	const notes = allNotes(review);
-	problems.push(...duplicates(round.replies.map((reply) => reply.note), (id) => `${at} has two replies to note ${id}. Say it all in one.`));
-	for (const reply of round.replies) {
-		if (!notes.has(reply.note)) problems.push(`${at} replies to note ${reply.note}, which doesn't exist.`);
-		if (reply.on) problems.push(...problemsWithPlace(reply.on.app ? { flow: reply.on.app.from.flow } : reply.on, round.flows, `${at}: the reply to note ${reply.note}`));
-		if (reply.watch) problems.push(...problemsWatching(reply, round, at));
-	}
-	return problems;
-}
-function problemsWatching(reply, round, at) {
-	const flow = reply.on && !reply.on.app ? round.flows.find((flow) => flow.name === reply.on.flow) : void 0;
-	if (!flow) return [`${at}: the reply to note ${reply.note} watches ${quote(reply.watch)}, but it isn't on one of this round's flows. Take "watch" out.`];
-	if (flow.steps.some((step) => step.title === reply.watch)) return [];
-	return [`${at}: the reply to note ${reply.note} watches ${quote(reply.watch)}, which isn't a step of ${quote(flow.name)}. Name one of its steps: ${list(flow.steps.map((step) => quote(step.title)))}.`];
-}
-function problemsAddingToBefore(review, flows, cantStart) {
-	if (review.accepted) return ["This review is accepted, so nothing more can be recorded."];
-	const before = review.rounds.find((round) => round.number === 0);
-	if (!before) return ["There's no Before to add a flow to: the app was new."];
-	const after = withInBefore(before, flows, cantStart);
-	const shape = problemsWithShape(Round, after, "Before");
-	return shape.length ? shape : problemsWithFlows(after, "Before");
-}
-function withInBefore(before, flows, cantStart) {
-	const names = /* @__PURE__ */ new Set([...flows.map((flow) => flow.name), ...cantStart]);
-	return {
-		...before,
-		flows: [...before.flows.filter((flow) => !names.has(flow.name)), ...flows],
-		cantStart: [...(before.cantStart ?? []).filter((name) => !names.has(name)), ...cantStart]
-	};
-}
-function problemsWithFlows(round, at) {
-	const problems = duplicates([...round.flows.map((flow) => flow.name), ...round.cantStart ?? []], (name) => `${at} has two flows called “${name}”.`);
-	for (const flow of round.flows) {
-		const steps = flow.steps.map((step) => step.title);
-		problems.push(...duplicates(steps, (title) => `${at}: the flow “${flow.name}” has two steps called “${title}”. Steps are matched by title.`));
-		for (const step of flow.steps.filter((step) => step.at > flow.length)) problems.push(`${at}: the step “${step.title}” in the flow “${flow.name}” starts after the flow ends.`);
-	}
-	return problems;
-}
-function problemsWithComparison(review, comparison) {
-	const shape = problemsWithShape(Comparison, comparison, "This comparison");
-	if (shape.length) return shape;
-	if (review.accepted) return ["This review is accepted, so nothing more can be recorded."];
-	const at = `Round ${comparison.round} against ${roundName(comparison.since)}`;
-	const round = review.rounds.find((kept) => kept.number === comparison.round);
-	const earlier = review.rounds.find((kept) => kept.number === comparison.since);
-	if (!round) return [`Round ${comparison.round} hasn't been recorded yet, so it can't be compared.`];
-	if (round.finished) return [`Round ${comparison.round} is finished, so what it's compared with can't change.`];
-	if (comparison.since >= comparison.round) return [`${at}: a round is only compared with a round before it.`];
-	if (!earlier) return [`${at}: there's no ${roundName(comparison.since)} to compare it with.`];
-	const problems = duplicates(comparison.changes.map((change) => change.id), (id) => `${at} has two changes with the id ${id}.`);
-	for (const change of comparison.changes) for (const seen of change.seen) {
-		const gone = seen.at === void 0 && !round.flows.some((flow) => flow.name === seen.flow);
-		problems.push(...problemsWithPlace(seen, gone ? earlier.flows : round.flows, `${at}: ${describe(change)}`));
-	}
-	return problems;
-}
-const LINE = 140;
-function problemsFinishing(review, number) {
-	if (review.accepted) return ["This review is accepted, so nothing more can be recorded."];
-	const round = review.rounds.find((round) => round.number === number);
-	if (!round) return [`Round ${number} hasn't been recorded yet.`];
-	const at = `Round ${number}`;
-	const shape = problemsWithShape(Round, round, at);
-	if (shape.length) return shape;
-	if (!round.flows.length) return [`${at} has no flows yet. Record them first.`];
-	const problems = [];
-	const notes = allNotes(review);
-	for (const id of notesToAnswer(review, number)) {
-		const reply = round.replies.find((reply) => reply.note === id);
-		const note = notes.get(id)?.note;
-		if (!isText$1(reply?.words)) problems.push(`${at} needs an answer to note ${id}${note ? `, “${cut$1(note.words)}”` : ""}.`);
-		else if (reply?.on && note?.on && reply.on.flow !== note.on.flow) problems.push(`${at}: the reply to note ${id} is on “${reply.on.flow}”, but the note is on “${note.on.flow}”. A reply goes in its note's flow.`);
-	}
-	for (const flow of round.flows) if (flow.line && flow.line.length > LINE) problems.push(`${at}: the line on “${flow.name}” is ${flow.line.length} characters. Say it in a sentence of up to ${LINE}: what it starts from, or the choice it shows.`);
-	const comparisons = review.comparisons.filter((comparison) => comparison.round === number);
-	if (comparisons.length) for (const earlier of review.rounds.filter((earlier) => earlier.number < number && !comparisons.some((comparison) => comparison.since === earlier.number))) problems.push(`${at} isn't compared with ${roundName(earlier.number)} yet, so it can't be handed over. Record it again.`);
-	const changes = new Map(comparisons.flatMap((comparison) => comparison.changes.map((change) => [change.id, change])));
-	for (const change of comparisons.find((comparison) => comparison.since === number - 1)?.changes ?? []) if (!round.accounts[change.id]) problems.push(`${at}: say why ${change.id} is there (${change.words}${where(change)}): its line, the note it was made for, or why nothing really changed.`);
-	for (const [id, account] of Object.entries(round.accounts)) {
-		const change = changes.get(id);
-		if (!change) problems.push(`${at} says something about the change ${id}, which isn't one of this round's changes.`);
-		else if ("note" in account && !notes.has(account.note)) problems.push(`${at}: ${describe(change)} was made for note ${account.note}, which doesn't exist.`);
-	}
-	return problems;
-}
-function problemsWithFile(review, round, name) {
-	if (review.accepted) return ["This review is accepted, so nothing more can be recorded."];
-	const due = roundInProgress(review);
-	if (round !== due && !(review.rounds.length === 0 && round === 1)) return [`Files go in the round being worked on, ${due}, not round ${round}.`];
-	return problemsWithFileName(name);
-}
-function problemsWithFileName(name) {
-	return fileName("").safeParse(name).success ? [] : [`“${name}” can't be a file's name: use letters, digits, dots, dashes and underscores, and slashes between folders.`];
-}
-function problemsWithSend(review, send) {
-	const shape = problemsWithShape(Send, send, "This send");
-	if (shape.length) return shape;
-	if (review.accepted) return ["This review is accepted, so nothing more can be sent."];
-	if (review.sends.some((other) => other.id === send.id)) return [`Something else was already sent as ${send.id}. Send this with a new id.`];
-	const takenBack = send.takenBack ?? [];
-	if (!send.notes.length && !send.verdicts.length && !send.looksGood.length && !takenBack.length) return ["There's nothing in this send."];
-	const round = review.rounds.find((round) => round.number === send.round);
-	if (send.round === 0) return ["Round 0 is Before: notes go on the rounds after it."];
-	if (!round?.finished) return [`Round ${send.round} isn't finished, so it can't take notes yet.`];
-	const problems = [];
-	const notes = allNotes(review);
-	problems.push(...duplicates(send.notes.map((note) => note.id), (id) => `This send has two notes with the id ${id}.`));
-	for (const note of send.notes) {
-		if (notes.has(note.id)) problems.push(`The id ${note.id} is already a note's. Make a new one.`);
-		if (note.on) problems.push(...problemsWithPlace(note.on.app ? { flow: note.on.app.from.flow } : note.on, round.flows, `Note ${note.id}`));
-	}
-	problems.push(...duplicates(send.verdicts.map((verdict) => verdict.note), (id) => `This send has two verdicts on note ${id}.`));
-	for (const verdict of send.verdicts) {
-		const known = notes.get(verdict.note);
-		if (send.notes.some((note) => note.id === verdict.note)) problems.push(`Note ${verdict.note} is new: it needs words, not a verdict.`);
-		else if (!known || known.round > send.round) problems.push(`There's no note ${verdict.note} on round ${send.round} to judge.`);
-	}
-	problems.push(...duplicates(send.looksGood, (flow) => `This send says “${flow}” looks good twice.`));
-	problems.push(...duplicates(takenBack, (flow) => `This send takes back Looks good on “${flow}” twice.`));
-	for (const flow of send.looksGood.filter((flow) => takenBack.includes(flow))) problems.push(`This send says “${flow}” looks good and takes that back: say one.`);
-	for (const flow of [...send.looksGood, ...takenBack].filter((flow) => !round.flows.some((recorded) => recorded.name === flow))) problems.push(`Round ${send.round} has no flow called “${flow}”.`);
-	return problems;
-}
-function problemsAccepting(review, by) {
-	if (!isText$1(by)) return ["Accepting needs to say who accepted."];
-	if (!review.rounds.some((round) => round.finished && round.number > 0)) return ["There's no finished round to accept yet."];
-	const notes = allNotes(review);
-	return waitingForTheAgent(review).map((id) => {
-		const note = notes.get(id);
-		return `Note ${id}${note ? `, “${cut$1(note.note.words)}”,` : ""} still waits for the agent's answer, so the work can't be accepted yet.`;
-	});
-}
-function problemsWithShape(schema, value, subject) {
-	const result = schema.safeParse(value, { error: plainly });
-	if (result.success) return [];
-	return result.error.issues.map((issue) => `${whose(subject, issue.path, value)} ${issue.message}.`);
-}
-const plainly = (issue) => {
-	const field = issue.path?.findLast((key) => typeof key === "string");
-	if (issue.code === "unrecognized_keys") return `has ${issue.keys.map((key) => `“${key}”`).join(" and ")}, which ${issue.keys.length > 1 ? "aren't" : "isn't"} one of its fields`;
-	if (issue.code === "invalid_type") {
-		if (field === void 0) return `isn't ${KINDS[issue.expected] ?? issue.expected}`;
-		if (issue.input === void 0) return issue.expected === "array" ? `needs its ${field}, a list, even if it's empty` : `needs its ${field}`;
-		return `has a ${field} that isn't ${KINDS[issue.expected] ?? issue.expected}`;
-	}
-	return field === void 0 ? "isn't right" : `has a ${field} that isn't right`;
-};
-const KINDS = {
-	string: "text",
-	number: "a number",
-	array: "a list",
-	object: "an object",
-	boolean: "true or false"
-};
-function whose(subject, path, value) {
-	const things = [];
-	let here = value;
-	for (const [i, key] of path.entries()) {
-		here = here && typeof here === "object" ? here[key] : void 0;
-		if (typeof key === "number") things.unshift(nameOf(String(path[i - 1]), here, key));
-		else if (path[i - 1] === "accounts") things.unshift(`what it says about the change ${String(key)}`);
-	}
-	return things.length ? `${subject}: ${things.join(" in ")}` : subject;
-}
-function nameOf(list, item, index) {
-	const { name, title, words, id, note } = item ?? {};
-	return {
-		flows: isText$1(name) && `the flow “${name}”`,
-		steps: isText$1(title) && `the step “${title}”`,
-		changes: isText$1(words) && `the change “${cut$1(words)}”` || isText$1(id) && `the change ${id}`,
-		replies: isText$1(note) && `the reply to note ${note}`,
-		notes: isText$1(id) && `note ${id}`,
-		verdicts: isText$1(note) && `the verdict on note ${note}`
-	}[list] || `${{
-		flows: "flow",
-		steps: "step",
-		changes: "change",
-		seen: "place it's seen",
-		replies: "reply",
-		notes: "note",
-		verdicts: "verdict",
-		looksGood: "flow said to look good"
-	}[list] ?? list} ${index + 1}`;
-}
-function problemsWithPlace(place, flows, what) {
-	const flow = flows.find((flow) => flow.name === place.flow);
-	if (!flow) return [`${what} is on the flow “${place.flow}”, which isn't there.`];
-	const end = Math.max(place.at ?? 0, place.until ?? 0);
-	return end <= flow.length ? [] : [`${what} is at ${end}s, but “${flow.name}” is ${flow.length}s long.`];
-}
-function duplicates(values, problem) {
-	const seen = /* @__PURE__ */ new Set();
-	return [...new Set(values.filter((value) => seen.has(value) || !seen.add(value)))].map(problem);
-}
-const roundName = (number) => number === 0 ? "Before" : `round ${number}`;
-const describe = (change) => `the change ${change.id} (${cut$1(change.words)})`;
-const where = ({ seen: [first] }) => first ? `, in ${quote(first.flow)}${first.at === void 0 ? "" : ` at ${time(first.at)}`}` : "";
-const cut$1 = (words) => words.length > 48 ? `${words.slice(0, 47).trimEnd()}…` : words;
-const isText$1 = (value) => typeof value === "string" && value.trim() !== "";
+import { fileURLToPath, pathToFileURL } from "node:url";
 // ../review/src/steps.ts
 function inStep(at, from, to, clicks) {
 	if (at <= 0) return at;
@@ -519,219 +68,292 @@ function pausedAt(flow, at) {
 		actions: 1
 	};
 }
-// ../review/src/store.ts
-var Refused = class extends Error {
-	problems;
-	constructor(problems) {
-		super(problems.join("\n"));
-		this.name = "Refused";
-		this.problems = problems;
-	}
-};
-var Reviews = class {
-	storage;
-	#queues = /* @__PURE__ */ new Map();
-	constructor(storage) {
-		this.storage = storage;
-	}
-	async list() {
-		const ids = (await this.storage.list("")).filter((id) => !problemsWithId(id).length);
-		const started = await Promise.all(ids.map(async (id) => await this.storage.read(`${id}/review.json`) !== void 0));
-		return ids.filter((_, i) => started[i]).sort();
-	}
-	async get(id) {
-		if (problemsWithId(id).length) throw new Refused(problemsWithId(id));
-		const about = await this.#readJson(`${id}/review.json`);
-		if (!about) throw new Refused([`There's no review called “${id}”.`]);
-		const numbers = (await this.storage.list(`${id}/rounds`)).map(Number).filter(Number.isInteger).sort((a, b) => a - b);
-		const rounds = await Promise.all(numbers.map((n) => this.#readJson(`${id}/rounds/${n}/round.json`)));
-		const comparisons = await Promise.all(numbers.map(async (n) => {
-			const names = (await this.storage.list(`${id}/rounds/${n}/since`)).filter((name) => name.endsWith(".json"));
-			return Promise.all(names.map((name) => this.#readJson(`${id}/rounds/${n}/since/${name}`)));
-		}));
-		const names = (await this.storage.list(`${id}/sends`)).filter((name) => name.endsWith(".json"));
-		const sends = await Promise.all(names.map((name) => this.#readJson(`${id}/sends/${name}`)));
-		const accepted = await this.#readJson(`${id}/accepted.json`);
-		return {
-			id,
-			title: about.title,
-			...about.asked && { asked: about.asked },
-			started: about.started,
-			rounds: rounds.filter((round) => round !== void 0),
-			comparisons: comparisons.flat().filter((comparison) => comparison !== void 0).sort((a, b) => a.round - b.round || a.since - b.since),
-			sends: sends.filter((send) => send !== void 0).sort((a, b) => a.sent.localeCompare(b.sent) || a.id.localeCompare(b.id)),
-			taken: await this.#readJson(`${id}/taken.json`) ?? [],
-			...accepted && { accepted }
-		};
-	}
-	async start(id, title, asked) {
-		return this.#one(id, async () => {
-			const problems = problemsStarting(id, title, asked);
-			if (problems.length) throw new Refused(problems);
-			if (await this.storage.read(`${id}/review.json`)) throw new Refused([`There's already a review called “${id}”.`]);
-			await this.#writeJson(`${id}/review.json`, {
-				format: 1,
-				id,
-				title,
-				...asked && { asked },
-				started: now()
-			});
-			return this.get(id);
-		});
-	}
-	async saveRound(id, round) {
-		return this.#one(id, async () => {
-			const review = await this.get(id);
-			const kept = {
-				...round,
-				finished: void 0
+// ../review/src/folder.ts
+const LOOK_EVERY = 2e3;
+function folder(root) {
+	return {
+		async read(path) {
+			try {
+				return new Uint8Array(await readFile(join(root, path)));
+			} catch (error) {
+				if (isMissing(error)) return void 0;
+				throw error;
+			}
+		},
+		async write(path, bytes) {
+			const file = join(root, path);
+			const unfinished = `${file}.${process.pid}.${Date.now()}.writing`;
+			await mkdir(dirname(file), { recursive: true });
+			await writeFile(unfinished, bytes);
+			await rename(unfinished, file);
+		},
+		async list(path) {
+			try {
+				return (await readdir(join(root, path))).filter((name) => !name.endsWith(".writing"));
+			} catch (error) {
+				if (isMissing(error)) return [];
+				throw error;
+			}
+		},
+		watch(path, changed) {
+			const look = setInterval(changed, LOOK_EVERY);
+			let watcher;
+			try {
+				watcher = watch(join(root, path), { recursive: true }, changed);
+				watcher.on("error", () => watcher?.close());
+			} catch {}
+			return () => {
+				clearInterval(look);
+				watcher?.close();
 			};
-			const problems = problemsWithRound(review, kept);
-			if (problems.length) throw new Refused(problems);
-			await this.#writeJson(`${id}/rounds/${round.number}/round.json`, kept);
-		});
-	}
-	async saveFile(id, round, name, bytes) {
-		return this.#one(id, async () => {
-			const problems = problemsWithFile(await this.get(id), round, name);
-			if (problems.length) throw new Refused(problems);
-			await this.storage.write(`${id}/rounds/${round}/files/${name}`, bytes);
-		});
-	}
-	async saveBranch(id, name, bytes) {
-		const problems = [...problemsWithId(id), ...problemsWithFileName(name)];
-		if (problems.length) throw new Refused(problems);
-		await this.storage.write(`${id}/branches/${name}`, bytes);
-	}
-	async branch(id, name) {
-		const problems = [...problemsWithId(id), ...problemsWithFileName(name)];
-		if (problems.length) throw new Refused(problems);
-		return this.storage.read(`${id}/branches/${name}`);
-	}
-	async take(id) {
-		return this.#one(id, async () => {
-			const review = await this.get(id);
-			if (review.accepted) return [];
-			const fresh = review.sends.filter((send) => !review.taken.some((taken) => taken.send === send.id));
-			if (!fresh.length) return [];
-			const round = roundInProgress(review);
-			const at = now();
-			await this.#writeJson(`${id}/taken.json`, [...review.taken, ...fresh.map((send) => ({
-				send: send.id,
-				round,
-				at
-			}))]);
-			return fresh;
-		});
-	}
-	async finish(id, round) {
-		return this.#one(id, async () => {
-			const review = await this.get(id);
-			const saved = review.rounds.find((saved) => saved.number === round);
-			if (saved?.finished) return;
-			const problems = problemsFinishing(review, round);
-			if (problems.length || !saved) throw new Refused(problems);
-			await this.#writeJson(`${id}/rounds/${round}/round.json`, {
-				...saved,
-				finished: now()
-			});
-		});
-	}
-	async addToBefore(id, added) {
-		return this.#one(id, async () => {
-			const review = await this.get(id);
-			const problems = problemsAddingToBefore(review, added.flows, added.cantStart);
-			for (const { name, bytes } of added.files) {
-				const named = problemsWithFileName(name);
-				problems.push(...named);
-				const there = named.length ? void 0 : await this.storage.read(`${id}/rounds/0/files/${name}`);
-				if (there && Buffer.compare(there, bytes)) problems.push(`Before has a file called “${name}” already, with something else in it.`);
+		}
+	};
+}
+const isMissing = (error) => error.code === "ENOENT";
+// src/repo.ts
+function repo(root = home(process.cwd())) {
+	const reviews = join(root, ".playthrough");
+	const appFile = join(root, "playthrough", "app.json");
+	return {
+		root,
+		reviews: new Reviews(folder(reviews)),
+		flows: (review) => join(reviews, review, "flows"),
+		failed: (review) => join(reviews, review, "failed"),
+		round: (review, round) => join(reviews, review, "rounds", String(round), "round.json"),
+		ranOnBefore: (review) => join(reviews, review, "ran-on-before.json"),
+		setAside: join(reviews, "set-aside.json"),
+		appFile,
+		setup: join(root, "playthrough", "setup.ts"),
+		borrowed: join(reviews, "borrowed"),
+		tried: join(reviews, "tried"),
+		show: (path) => relative(process.cwd(), path) || ".",
+		async keepOutOfGit() {
+			await mkdir(reviews, { recursive: true });
+			await writeFile(join(reviews, ".gitignore"), "*\n");
+		},
+		async app() {
+			const how = `Say how to start the app in playthrough/app.json: { "start": "<the command that serves it>", "url": "<where it's served>" }.`;
+			const text = await readFile(appFile, "utf8").catch(() => void 0);
+			if (text === void 0) throw new Refused([`Playthrough needs to start the app to record it. ${how}`]);
+			let app;
+			try {
+				app = JSON.parse(text);
+			} catch (error) {
+				throw new Refused([`playthrough/app.json isn't JSON: ${error.message}. ${how}`]);
 			}
-			if (problems.length) throw new Refused(problems);
-			const before = review.rounds.find((round) => round.number === 0);
-			for (const { name, bytes } of added.files) await this.storage.write(`${id}/rounds/0/files/${name}`, bytes);
-			await this.#writeJson(`${id}/rounds/0/round.json`, withInBefore(before, added.flows, added.cantStart));
-		});
+			if (!isText(app.start) || !isText(app.url)) throw new Refused([`playthrough/app.json needs both “start” and “url”. ${how}`]);
+			if (app.oneAtATime !== void 0 && typeof app.oneAtATime !== "boolean") throw new Refused([`playthrough/app.json's “oneAtATime” is true or false: true runs each flow by itself.`]);
+			return {
+				start: app.start,
+				url: app.url,
+				...app.oneAtATime && { oneAtATime: true }
+			};
+		}
+	};
+}
+function home(here) {
+	for (let folder = here;; folder = dirname(folder)) {
+		if (existsSync(join(folder, ".playthrough")) || existsSync(join(folder, "playthrough", "app.json"))) return folder;
+		if (existsSync(join(folder, ".git")) || dirname(folder) === folder) return here;
 	}
-	async saveComparison(id, comparison) {
-		return this.#one(id, async () => {
-			const problems = problemsWithComparison(await this.get(id), comparison);
-			if (problems.length) throw new Refused(problems);
-			await this.#writeJson(`${id}/rounds/${comparison.round}/since/${comparison.since}.json`, comparison);
-		});
+}
+const isText = (value) => typeof value === "string" && value.trim() !== "";
+// src/setup.ts
+const OURS = [
+	"baseURL",
+	"viewport",
+	"screen",
+	"isMobile",
+	"hasTouch",
+	"deviceScaleFactor",
+	"locale",
+	"timezoneId",
+	"colorScheme",
+	"reducedMotion",
+	"forcedColors",
+	"contrast"
+];
+async function setupIn(file, written) {
+	if (!existsSync(file)) return {};
+	const href = pathToFileURL(file).href;
+	asModule(href);
+	const module = await import(`${href}${written ? `?${written}` : ""}`);
+	const inner = typeof module.default === "object" ? module.default : void 0;
+	const use = module.use ?? inner?.use;
+	const ours = Object.keys(use ?? {}).filter((option) => OURS.includes(option));
+	if (ours.length) throw new Refused([`playthrough/setup.ts's use sets ${list(ours)}, which Playthrough keeps the same for every flow, or a flow sets with test.use, like its screen. Take ${ours.length > 1 ? "them" : "it"} out of use.`]);
+	return {
+		make: typeof module.default === "function" ? module.default : inner?.default,
+		after: module.after ?? inner?.after,
+		signIn: module.signIn ?? inner?.signIn,
+		people: module.people ?? inner?.people,
+		...use && { use }
+	};
+}
+const setups = /* @__PURE__ */ new Set();
+function asModule(href) {
+	if (!setups.size) modules.registerHooks({ load: (url, context, next) => next(url, setups.has(url.split("?")[0]) ? {
+		...context,
+		format: "module-typescript"
+	} : context) });
+	setups.add(href);
+}
+const changes = (method) => ![
+	"GET",
+	"HEAD",
+	"OPTIONS"
+].includes(method.toUpperCase());
+function watching(request, changed) {
+	return new Proxy(request, { get(target, name) {
+		const value = Reflect.get(target, name);
+		if (typeof value !== "function") return value;
+		return (...args) => {
+			const [to, options] = args;
+			const method = name === "fetch" ? options?.method ?? (typeof to === "string" ? "GET" : to.method()) : String(name);
+			if ([
+				"post",
+				"put",
+				"patch",
+				"delete",
+				"fetch"
+			].includes(String(name)) && changes(method)) changed();
+			return value.apply(target, args);
+		};
+	} });
+}
+const firstOf$1 = ({ people }) => Object.keys(people ?? {})[0];
+function personIn({ people }, person) {
+	if (people && !(person in people)) throw new Error(`playthrough/setup.ts names no one called ${quote(person)}. Its people: ${list(Object.keys(people).map(quote))}. Add them there, or do the flow as one of them.`);
+}
+async function make({ make, after }, borrowed, given) {
+	const setup = await make?.(given) ?? {};
+	if (!after) return {
+		setup,
+		giveBack: async () => false
+	};
+	await mkdir(borrowed, { recursive: true });
+	const file = join(borrowed, `${process.pid}-${randomUUID()}.json`);
+	await writeFile(file, JSON.stringify({
+		baseURL: given.baseURL,
+		setup
+	}));
+	return {
+		setup,
+		giveBack: () => giveBack(after, file, given.baseURL, setup)
+	};
+}
+const giveBackLeft = (setup, borrowed) => giveBackOf(setup, borrowed, (pid) => !alive(pid));
+const giveBackOwn = (setup, borrowed) => giveBackOf(setup, borrowed, (pid) => pid === process.pid);
+async function giveBackOf({ after }, borrowed, whose) {
+	if (!after) return;
+	const left = (await readdir(borrowed).catch(() => [])).filter((name) => whose(Number(name.split("-")[0])));
+	for (const name of left) {
+		const file = join(borrowed, `${process.pid}-${name.slice(name.indexOf("-") + 1)}`);
+		if (!await rename(join(borrowed, name), file).then(() => true, () => false)) continue;
+		const { baseURL, setup } = JSON.parse(await readFile(file, "utf8"));
+		await giveBack(after, file, baseURL, setup);
 	}
-	async send(id, send) {
-		return this.#one(id, async () => {
-			const review = await this.get(id);
-			const already = review.sends.find((sent) => sent.id === send.id);
-			if (already && JSON.stringify(already) === JSON.stringify(send)) return;
-			const problems = problemsWithSend(review, send);
-			if (problems.length) throw new Refused(problems);
-			await this.#writeJson(`${id}/sends/${send.id}.json`, send);
+}
+const giving = /* @__PURE__ */ new Set();
+async function giveBack(after, file, baseURL, setup) {
+	if (giving.has(file) || !existsSync(file)) return true;
+	giving.add(file);
+	const request$2 = await request.newContext({ baseURL });
+	try {
+		await after({
+			request: request$2,
+			baseURL,
+			setup
 		});
+		await rm(file, { force: true });
+		return true;
+	} catch (error) {
+		console.log(`playthrough/setup.ts's after couldn't give back what a run made: ${firstLine(String(error?.message ?? error))}. It's tried again by the next command.`);
+		return false;
+	} finally {
+		giving.delete(file);
+		await request$2.dispose();
 	}
-	async accept(id, by) {
-		return this.#one(id, async () => {
-			const review = await this.get(id);
-			if (review.accepted) return;
-			const problems = problemsAccepting(review, by);
-			if (problems.length) throw new Refused(problems);
-			await this.#writeJson(`${id}/accepted.json`, {
-				by,
-				at: now()
-			});
-		});
+}
+function alive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
 	}
-	async file(id, round, name) {
-		const problems = [...problemsWithId(id), ...problemsWithFileName(name)];
-		if (problems.length || !Number.isInteger(round)) throw new Refused(problems.length ? problems : [`There's no round ${round}.`]);
-		return this.storage.read(`${id}/rounds/${round}/files/${name}`);
+}
+// src/app.ts
+let started;
+let ending = false;
+async function keepRunning(app, root) {
+	if (!ending) {
+		ending = true;
+		const { setup, borrowed } = repo(root);
+		const giveBack = () => setupIn(setup).then((setup) => giveBackOwn(setup, borrowed));
+		const end = (signal) => void Promise.race([giveBack(), new Promise((wait) => setTimeout(wait, 1e4))]).finally(() => process.exit(128 + constants.signals[signal]));
+		for (const signal of [
+			"SIGINT",
+			"SIGTERM",
+			"SIGHUP"
+		]) process.once(signal, end);
+		process.once("exit", stop);
 	}
-	async wait(id, until, signal) {
-		signal?.throwIfAborted();
-		return new Promise((resolve, reject) => {
-			let looking = false;
-			let again = false;
-			const done = (end) => {
-				stop();
-				signal?.removeEventListener("abort", aborted);
-				end();
-			};
-			const look = async () => {
-				if (looking) return void (again = true);
-				looking = true;
-				try {
-					do {
-						again = false;
-						const review = await this.get(id);
-						if (until(review)) return done(() => resolve(review));
-					} while (again);
-				} catch (error) {
-					done(() => reject(error));
-				} finally {
-					looking = false;
-				}
-			};
-			const aborted = () => done(() => reject(signal?.reason));
-			const stop = this.storage.watch(id, look);
-			signal?.addEventListener("abort", aborted, { once: true });
-			look();
+	if (await serves(app.url)) return;
+	console.log(`Starting the app: ${app.start}`);
+	const began = Date.now();
+	started = spawn(app.start, {
+		cwd: root,
+		shell: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: true
+	});
+	const said = [];
+	for (const output of [started.stdout, started.stderr]) {
+		output.on("data", (chunk) => {
+			said.push(...chunk.toString().split("\n").filter((line) => line.trim() && !/^\s+at /.test(line)));
+			said.splice(0, said.length - 10);
 		});
-	}
-	#one(id, step) {
-		const next = (this.#queues.get(id) ?? Promise.resolve()).catch(() => {}).then(step);
-		this.#queues.set(id, next);
-		return next;
-	}
-	async #readJson(path) {
-		const bytes = await this.storage.read(path);
-		return bytes && JSON.parse(new TextDecoder().decode(bytes));
-	}
-	#writeJson(path, value) {
-		return this.storage.write(path, new TextEncoder().encode(`${JSON.stringify(value, null, 2)}\n`));
-	}
-};
-const now = () => (/* @__PURE__ */ new Date()).toISOString();
+		output.unref();
+	}
+	started.unref();
+	let ended = false;
+	started.once("exit", () => ended = true);
+	const saying = () => said.length ? ["It said, last:", ...said.map((line) => `  ${line}`)] : [];
+	while (Date.now() - began < 18e4) {
+		if (await serves(app.url)) return Date.now() - began;
+		if (ended) throw new Refused([
+			`${quote(app.start)} ended before the app answered at ${app.url}.`,
+			...saying(),
+			"Check that playthrough/app.json starts the app there."
+		]);
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	stop();
+	throw new Refused([
+		`The app didn't answer at ${app.url} within three minutes of ${quote(app.start)}.`,
+		...saying(),
+		"Check that playthrough/app.json starts it there."
+	]);
+}
+async function stopApp(url) {
+	if (!stop()) return;
+	const began = Date.now();
+	while (Date.now() - began < 1e4 && await serves(url)) await new Promise((resolve) => setTimeout(resolve, 250));
+}
+function stop() {
+	if (!started) return false;
+	try {
+		process.kill(-started.pid);
+	} catch {}
+	started = void 0;
+	return true;
+}
+const serves = (url) => fetch(url, { signal: AbortSignal.timeout(2e3) }).then((response) => (response.body?.cancel(), true), (error) => error?.name === "TimeoutError");
 // ../page/src/names.ts
 const WORD = {
 	button: "button",
@@ -761,7 +383,7 @@ const WORD = {
 const word = (thing) => WORD[thing.role] ?? thing.role;
 const symbolOnly = (thing) => (thing.role === "button" || thing.role === "link") && !!thing.name && thing.words.replace(/\s/g, "").length <= 2 && !/[\p{L}\p{N}]/u.test(thing.words);
 const cut = (words, most = 60) => words.length > most ? words.slice(0, most - 1).trimEnd() + "…" : words;
-function called(thing) {
+function called$1(thing) {
 	if (thing.role === "status" || thing.role === "alert") return "Message";
 	if (thing.role === "box") return `“${cut(areaName(thing))}” ${thing.live ? "message" : "area"}`;
 	if (thing.role === "text") return `“${cut(thing.words)}”`;
@@ -775,7 +397,7 @@ function areaName({ name, wordsInside }) {
 	return wordsInside.slice(name.length).trim() || name;
 }
 const the = (thing) => {
-	const name = called(thing);
+	const name = called$1(thing);
 	return name === "Message" ? "the message" : name.startsWith("“") && thing.role === "text" ? name : `the ${name}`;
 };
 const a = (word) => /^[aeiou]/.test(word) ? `an ${word}` : `a ${word}`;
@@ -784,7 +406,7 @@ const things = (count) => count > 1 ? "things" : "thing";
 const dataLeftOut = (words) => words.replace(/\d[\d.,:/]*/g, "…");
 const sentence = (words) => words.charAt(0).toUpperCase() + words.slice(1);
 const wayOf = (across, down) => [down > 0 ? "down" : down < 0 ? "up" : "", across > 0 ? "right" : across < 0 ? "left" : ""].filter(Boolean).join(" and ");
-function together(all, name = called) {
+function together(all, name = called$1) {
 	if (all.every((thing) => thing.role === "menuitem" && thing.name)) return `${together(all, (thing) => `“${thing.name}”`)} in the menu`;
 	const names = all.map(name);
 	let shared = names.reduce((common, next) => {
@@ -799,7 +421,7 @@ function together(all, name = called) {
 	return `${shown.slice(0, -1).join(", ")} and ${shown.at(-1)}`;
 }
 function rewordedWords(a, b) {
-	if (a.role !== "text") return `${called(a)} now says “${cut(b.name)}”`;
+	if (a.role !== "text") return `${called$1(a)} now says “${cut(b.name)}”`;
 	let start = 0;
 	while (start < a.words.length && start < b.words.length && a.words[start] === b.words[start]) start++;
 	let end = 0;
@@ -929,7 +551,7 @@ function differences(then, now) {
 			});
 			continue;
 		}
-		a = b.role !== "text" ? take((a) => a.role === b.role && (a.name === b.name || samePlace(a, b) || mostlyWhereItWas(a, b) || holdsTheSameWords(a, b))) : take((a) => a.role === "text" && samePlace(a, b)) ?? (holderOf(now, b) && goneWords.get(holderKey(now, b)) === newWords.get(holderKey(now, b)) ? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b)) : void 0) ?? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b) && !!bare(b.words) && bare(a.words) === bare(b.words));
+		a = b.role !== "text" ? take((a) => a.role === b.role && (a.name === b.name || samePlace(a, b) || mostlyWhereItWas(a, b) || holdsTheSameWords(a, b) || CONTROL.test(b.role) && (!!bare(b.name) && bare(a.name) === bare(b.name) || overlap(a, b) > .5))) : take((a) => a.role === "text" && samePlace(a, b)) ?? (holderOf(now, b) && goneWords.get(holderKey(now, b)) === newWords.get(holderKey(now, b)) ? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b)) : void 0) ?? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b) && !!bare(b.words) && bare(a.words) === bare(b.words));
 		if (!a) {
 			found.push({
 				what: "new",
@@ -1065,6 +687,7 @@ function compared(a, b) {
 		then: a,
 		now: b
 	};
+	if (unseenBox(a, b)) return void 0;
 	if (!near(a.box.width, b.box.width) || !near(a.box.height, b.box.height)) return {
 		what: "resized",
 		then: a,
@@ -1076,6 +699,11 @@ function compared(a, b) {
 		now: b
 	};
 }
+function unseenBox(a, b) {
+	const boxless = (thing) => /^(transparent|rgba\(0, 0, 0, 0\))$/.test(thing.look.background) && thing.look.border === "none";
+	const edges = near(a.page.x, b.page.x) || near(a.page.x + a.box.width, b.page.x + b.box.width);
+	return a.role === "text" && a.words === b.words && boxless(a) && boxless(b) && near(a.box.height, b.box.height) && near(a.page.y, b.page.y) && edges;
+}
 function gained(reading, control, was) {
 	if (!was || !control.name.startsWith(was + " ")) return false;
 	const more = control.name.slice(was.length + 1);
@@ -1334,12 +962,12 @@ function swappedOrMoved(moment, loose) {
 				what: "moved",
 				thing: move.now,
 				in: moment.now,
-				words: `${called(move.now)} ${movedWords(moment, move)}`
+				words: `${called$1(move.now)} ${movedWords(moment, move)}`
 			});
 			continue;
 		}
 		const order = [...moves].sort((p, q) => p.now.page.x - q.now.page.x || p.now.page.y - q.now.page.y);
-		const words = moves.length === 2 ? `${together(order.map((move) => move.now))} have swapped places` : `What's in ${the(holder)} is in a new order: ${order.slice(0, 3).map((move) => called(move.now)).join(", ")}${moves.length > 3 ? "…" : ""}`;
+		const words = moves.length === 2 ? `${together(order.map((move) => move.now))} have swapped places` : `What's in ${the(holder)} is in a new order: ${order.slice(0, 3).map((move) => called$1(move.now)).join(", ")}${moves.length > 3 ? "…" : ""}`;
 		told.push({
 			what: "swapped",
 			thing: holder,
@@ -1407,7 +1035,7 @@ function causesOfShifts(moment, shifts, widened, others, caused, along) {
 		};
 		const candidates = others.filter((d) => !caused.has(d));
 		const span = spanOf(pushed);
-		const cause = moment.into(firstOf$1(moves)) ? void 0 : causeOf(span, looking, candidates) ?? (vertical ? void 0 : causeOf(span, {
+		const cause = moment.into(firstOf(moves)) ? void 0 : causeOf(span, looking, candidates) ?? (vertical ? void 0 : causeOf(span, {
 			...looking,
 			share: 0
 		}, candidates));
@@ -1427,19 +1055,37 @@ function causesOfShifts(moment, shifts, widened, others, caused, along) {
 		passed.add(shift);
 	}
 	return unexplained.filter((shift) => !passed.has(shift)).map((shift) => {
-		const first = firstOf$1(shift.moves);
-		const more = shift.moves.length > 1 ? `, with ${shift.moves.length - 1} more ${things(shift.moves.length - 1)} around it` : "";
+		const first = firstOf(shift.moves);
 		const pushed = movedPast.get(shift);
+		const other = pushed && unexplained.find((one) => passed.has(one) && one.moves.some((move) => pushed.things.includes(move.now)));
+		if (other && alikeInSize(shift, other)) {
+			const calledBy = (shift) => shift.moves.find((move) => move.now.role === "text")?.now ?? firstOf(shift.moves).now;
+			const both = [calledBy(shift), calledBy(other)].sort((p, q) => p.page.y - q.page.y || p.page.x - q.page.x);
+			return {
+				what: "swapped",
+				thing: both[0],
+				in: moment.now,
+				words: `${together(both)} have swapped places`
+			};
+		}
+		const alike = shift.moves.every((move) => move.now.item !== void 0 && move.now.role === first.now.role) && new Set(shift.moves.map((move) => move.now.item)).size === shift.moves.length;
+		const them = alike ? together([...shift.moves].sort((p, q) => p.now.page.y - q.now.page.y || p.now.page.x - q.now.page.x).map((move) => move.now)) : called$1(first.now);
+		const more = shift.moves.length > 1 && !alike ? `, with ${shift.moves.length - 1} more ${things(shift.moves.length - 1)} around it` : "";
 		return {
 			what: "moved",
 			thing: first.now,
 			in: moment.now,
-			words: `${called(first.now)} ${movedWords(moment, first)}${more}`,
+			words: `${them} ${movedWords(moment, first)}${more}`,
 			...pushed && { pushed }
 		};
 	});
 }
-const firstOf$1 = (moves) => [...moves].sort((p, q) => p.now.page.y - q.now.page.y || p.now.page.x - q.now.page.x)[0];
+function alikeInSize(one, other) {
+	const [few, many] = [one.moves.length, other.moves.length].sort((p, q) => p - q);
+	const [less, more] = [Math.hypot(one.by.x, one.by.y), Math.hypot(other.by.x, other.by.y)].sort((p, q) => p - q);
+	return few * 2 >= many && less * 2 >= more;
+}
+const firstOf = (moves) => [...moves].sort((p, q) => p.now.page.y - q.now.page.y || p.now.page.x - q.now.page.x)[0];
 function wentPast(mover, moved) {
 	const [was, is] = [spanOf(mover.moves.map((move) => move.then)), spanOf(mover.moves.map((move) => move.now))];
 	const [wasThere, isThere] = [spanOf(moved.moves.map((move) => move.then)), spanOf(moved.moves.map((move) => move.now))];
@@ -1476,21 +1122,21 @@ function tell(moment, difference, along = {}) {
 			what: "new",
 			thing: difference.now,
 			in: now,
-			words: `${called(difference.now)} is new`,
+			words: `${called$1(difference.now)} is new`,
 			...along
 		};
 		case "gone": return {
 			what: "gone",
 			thing: difference.then,
 			in: moment.then,
-			words: `${called(difference.then)} is gone`,
+			words: `${called$1(difference.then)} is gone`,
 			...along
 		};
 		case "became": return {
 			what: "became",
 			thing: difference.now,
 			in: now,
-			words: `${called(difference.then)} is ${a(word(difference.now))} now`,
+			words: `${called$1(difference.then)} is ${a(word(difference.now))} now`,
 			...along
 		};
 		case "reworded": return {
@@ -1502,7 +1148,7 @@ function tell(moment, difference, along = {}) {
 		};
 		case "looks different": {
 			const size = sizeWords(moment, difference);
-			const words = `${called(difference.now)} looks different: ${lookWords(difference.then, difference.now)}${size ? `, and ${size}` : ""}`;
+			const words = `${called$1(difference.now)} looks different: ${lookWords(difference.then, difference.now)}${size ? `, and ${size}` : ""}`;
 			return {
 				what: "looks different",
 				thing: difference.now,
@@ -1515,7 +1161,7 @@ function tell(moment, difference, along = {}) {
 			what: difference.what,
 			thing: difference.now,
 			in: now,
-			words: `${called(difference.now)} ${sizeWords(moment, difference)}`,
+			words: `${called$1(difference.now)} ${sizeWords(moment, difference)}`,
 			...along
 		};
 	}
@@ -1542,8 +1188,9 @@ function sizeWords(moment, pair) {
 }
 function said(told, moment, unsteady) {
 	const { now, was, isNow } = moment;
-	const id = (told) => idOf(identity(told.in, told.thing), told.what);
-	const inside = groupBy([...groupBy(told.filter((one) => !unsteady.has(id(one))).sort((p, q) => p.thing.page.y - q.thing.page.y || p.thing.page.x - q.thing.page.x), id).values()], ([told]) => {
+	const id = (told) => idOf(told.key ?? identityOf(told, moment), told.what);
+	const piecesOf = (told) => told.pieces ?? [id(told)];
+	const inside = groupBy([...groupBy(asItems(told.filter((one) => !unsteady.has(id(one))), moment, id).sort((p, q) => p.thing.page.y - q.thing.page.y || p.thing.page.x - q.thing.page.x), id).values()], ([told]) => {
 		const holder = holderOf(told.in, told.thing);
 		const holderNow = holder && (told.in === now ? holder : isNow.get(holder));
 		return holderNow && TABLES.test(holderNow.role) && was.has(holderNow) ? holderNow : void 0;
@@ -1555,12 +1202,13 @@ function said(told, moment, unsteady) {
 				id: id(alike[0]),
 				words: alikeWords(alike),
 				...placeOf(alike[0], now),
-				...alikeOf(alike, now)
+				...alikeOf(alike, now),
+				pieces: alike.flatMap(piecesOf)
 			});
 			continue;
 		}
 		const count = all.flat().length;
-		const words = all.flat().every((told) => told.what === "resized" || told.what === "moved") ? `Columns in ${the(holder)} changed width` : `${called(holder)}: ${count} ${things(count)} changed inside`;
+		const words = all.flat().every((told) => told.what === "resized" || told.what === "moved") ? `Columns in ${the(holder)} changed width` : `${called$1(holder)}: ${count} ${things(count)} changed inside`;
 		const changed = {
 			what: "changed inside",
 			thing: holder,
@@ -1570,11 +1218,130 @@ function said(told, moment, unsteady) {
 		found.push({
 			id: id(changed),
 			words: sentence(words),
-			...placeOf(changed, now)
+			...placeOf(changed, now),
+			pieces: all.flat().flatMap(piecesOf)
 		});
 	}
 	return found;
 }
+function identityOf({ in: reading, thing, what }, moment) {
+	const item = thing.item === void 0 ? void 0 : reading.items?.[thing.item];
+	if (!item) return identity(reading, thing);
+	const kind = reading.things.filter((other) => other.item === thing.item && other.role === thing.role && other.column === thing.column);
+	const place = `${thing.role} ${kind.indexOf(thing) + 1}${thing.column ? ` under ${thing.column}` : ""}`;
+	const was = what === "reworded" && moment.was.get(thing);
+	return `${place} in a ${item.role} of ${listOf(reading, item)}${was ? `: ${shapeOf(was.words, thing.words)}` : ""}`;
+}
+const listOf = (reading, item) => item.holder === void 0 ? "the page" : identity(reading, reading.things[item.holder], 0);
+function pairItems({ then, now, was }) {
+	const [before, after] = [then.items ?? [], now.items ?? []];
+	const pairs = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	const votes = /* @__PURE__ */ new Map();
+	for (const [b, a] of was) if (a.item !== void 0 && b.item !== void 0 && a.name === b.name && a.words === b.words) votes.set(`${a.item} ${b.item}`, (votes.get(`${a.item} ${b.item}`) ?? 0) + 1);
+	for (const [pair] of [...votes].sort((p, q) => q[1] - p[1])) {
+		const [a, b] = pair.split(" ").map(Number);
+		if (pairs.has(a) || taken.has(b)) continue;
+		pairs.set(a, b);
+		taken.add(b);
+	}
+	const lists = /* @__PURE__ */ new Map();
+	for (const [a, b] of pairs) if (!lists.has(before[a].list)) lists.set(before[a].list, after[b].list);
+	const left = (items, used) => [...new Set(items.map((item) => item.list))].filter((list) => !used.has(list));
+	const listsNow = left(after, new Set(lists.values()));
+	left(before, new Set(lists.keys())).forEach((list, i) => listsNow[i] !== void 0 && lists.set(list, listsNow[i]));
+	for (const [listThen, listNow] of lists) {
+		const a = before.flatMap((item, i) => item.list === listThen && !pairs.has(i) ? [i] : []);
+		const b = after.flatMap((item, i) => item.list === listNow && !taken.has(i) ? [i] : []);
+		if (a.length === b.length) a.forEach((i, k) => (pairs.set(i, b[k]), taken.add(b[k])));
+	}
+	return pairs;
+}
+function asItems(told, moment, id) {
+	const { then, now } = moment;
+	const items = pairItems(moment);
+	const was = new Map([...items].map(([a, b]) => [b, a]));
+	const itemOf = (one) => {
+		if (one.thing.item === void 0 || !/^(new|gone|reworded|became)$/.test(one.what)) return void 0;
+		if (one.in === now) return `now ${one.thing.item}`;
+		const paired = items.get(one.thing.item);
+		return paired === void 0 ? `then ${one.thing.item}` : `now ${paired}`;
+	};
+	const out = [];
+	for (const [key, all] of groupBy(told, itemOf)) {
+		if (!key || all.length < 2) {
+			out.push(...all);
+			continue;
+		}
+		const [side, at] = key.split(" ");
+		const [reading, index] = [side === "then" ? then : now, Number(at)];
+		const item = reading.items[index];
+		const thing = asThing(item, index);
+		const pieces = all.flatMap((one) => one.pieces ?? [id(one)]);
+		const along = all.find((one) => one.pushed || one.sized);
+		const whole = {
+			thing,
+			in: reading,
+			pieces,
+			...along?.pushed && { pushed: along.pushed },
+			...along?.sized && { sized: along.sized }
+		};
+		if (side === "then" || !was.has(index) && all.every((one) => one.what === "new")) {
+			const what = side === "then" ? "gone" : "new";
+			out.push({
+				...whole,
+				what,
+				words: `${called$1(thing)} is ${what}`,
+				key: `${item.role} of ${listOf(reading, item)}`
+			});
+			continue;
+		}
+		const before = was.has(index) ? then.items[was.get(index)] : void 0;
+		const words = all.filter((one) => one.thing.role === "text");
+		if (!before || before.words === item.words || words.length < 2) {
+			out.push(...all);
+			continue;
+		}
+		const reworded = rewordedWords(asThing(before, was.get(index), "text"), asThing(item, index, "text"));
+		out.push({
+			...whole,
+			what: "reworded",
+			words: reworded,
+			pieces: words.flatMap((one) => one.pieces ?? [id(one)]),
+			key: `${item.role} of ${listOf(now, item)}: ${shapeOf(before.words, item.words)}`
+		}, ...all.filter((one) => one.thing.role !== "text"));
+	}
+	return out;
+}
+function asThing(item, index, role = item.role) {
+	const name = item.words.replace(/^(\p{Lu})\s+(?=\1)/u, "").split(" ").filter((word) => /[\p{L}\p{N}]/u.test(word)).join(" ");
+	return {
+		role,
+		name: name.slice(0, 120),
+		words: role === "text" ? item.words : name,
+		box: item.box,
+		page: item.page,
+		look: {
+			color: "",
+			background: "",
+			size: "",
+			weight: "",
+			border: ""
+		},
+		item: index,
+		...item.holder !== void 0 && { holder: item.holder },
+		...item.node !== void 0 && { node: item.node }
+	};
+}
+function shapeOf(then, now) {
+	const [a, b] = [then.split(" "), now.split(" ")];
+	let start = 0;
+	while (start < a.length && start < b.length && a[start] === b[start]) start++;
+	let end = 0;
+	while (end < a.length - start && end < b.length - start && a.at(-1 - end) === b.at(-1 - end)) end++;
+	const part = (words) => words.slice(start, words.length - end).map((word) => /\d/.test(word) ? "…" : word).join(" ");
+	return `${part(a)} → ${part(b)}`;
+}
 function alikeWords(alike) {
 	const [first] = alike;
 	const them = (along) => along.things.length === 1 ? the(along.things[0]) : `${along.things.length} things`;
@@ -1591,9 +1358,10 @@ function alikeWords(alike) {
 		const them = symbolOnly(first.thing) ? together(all) : `${together(all, (thing) => thing.name)} ${plural(WORD[first.thing.role])}`;
 		return sentence(`${them} ${verb}${along}`);
 	}
-	const name = called(first.thing);
+	if (names.length > 1 && /^(new|gone)$/.test(first.what) && !WORD[first.thing.role]) return sentence(`${together(alike.map((told) => told.thing))} are ${first.what}${along}`);
+	const name = called$1(first.thing);
 	const bare = dataLeftOut(name);
-	const shared = new Set(alike.map((told) => called(told.thing))).size > 1 && first.words.startsWith(name) && /[^“”…\s]/.test(bare) ? bare + first.words.slice(name.length) : first.words;
+	const shared = new Set(alike.map((told) => called$1(told.thing))).size > 1 && first.words.startsWith(name) && /[^“”…\s]/.test(bare) ? bare + first.words.slice(name.length) : first.words;
 	return sentence(`${shared}${along}, in ${alike.length} places`);
 }
 function idOf(thing, what) {
@@ -1671,6 +1439,7 @@ function groupBy(items, key) {
 	return groups;
 }
 // src/pictures.ts
+const HERE = "here:";
 async function picturesAt(page, then, now, pictures) {
 	if (scrollOf(then) !== scrollOf(now)) return [];
 	const { differences: found } = differences(then, now);
@@ -1692,15 +1461,17 @@ async function picturesAt(page, then, now, pictures) {
 		const same = told.get(id);
 		told.set(id, {
 			words,
-			patch: same ? around$1(same.patch, patch) : patch
+			patch: same ? around$1(same.patch, patch) : patch,
+			here: !on.identity || on.identity.startsWith("near ")
 		});
 	}
-	return [...told].map(([id, { words, patch }]) => {
+	return [...told].map(([id, { words, patch, here }]) => {
 		const box = onScreen(patch, now.screen);
 		return {
 			id,
 			words: sentence(words),
-			...box && { box }
+			...box && { box },
+			pieces: [here ? `${HERE}${id}` : id]
 		};
 	});
 }
@@ -1717,7 +1488,7 @@ function whatsThere(reading, patch) {
 		identity: `column:${bare(cell.column)} in ${identity(reading, table)}`
 	};
 	if (round) return {
-		called: called(round),
+		called: called$1(round),
 		identity: bare(round.name) ? identity(reading, round) : void 0
 	};
 	const gap = (thing) => Math.hypot(Math.max(thing.box.x - patch.x - patch.width, 0, patch.x - thing.box.x - thing.box.width), Math.max(thing.box.y - patch.y - patch.height, 0, patch.y - thing.box.y - thing.box.height));
@@ -1897,7 +1668,7 @@ async function differ({ then, now, explained }) {
 async function compareWithEarlier(reviews, id, number, flows) {
 	const earlier = (await reviews.get(id)).rounds.filter((round) => round.number < number);
 	if (!earlier.length) return [];
-	const unsteady = new Set([...earlier.flatMap((round) => round.flows), ...flows].flatMap((flow) => flow.unsteady ?? []));
+	const unsteady = unsteadyIn([...earlier.flatMap((round) => round.flows), ...flows]);
 	const browser = await chromium.launch();
 	try {
 		const page = await browser.newPage();
@@ -1912,7 +1683,11 @@ async function compareWithEarlier(reviews, id, number, flows) {
 async function changesByThemselves(first, second) {
 	const browser = await chromium.launch();
 	try {
-		return (await compare(await browser.newPage(), first, second)).changes;
+		const { changes, pieces } = await comparing(await browser.newPage(), first, second);
+		return changes.map((change) => ({
+			...change,
+			pieces: [...pieces.get(change.id)]
+		}));
 	} finally {
 		await browser.close();
 	}
@@ -1935,11 +1710,22 @@ function kept(reviews, id, number, flows) {
 		picture: file
 	};
 }
-async function compare(page, earlier, round, unsteady = /* @__PURE__ */ new Set()) {
+async function compare(page, earlier, round, unsteady = () => /* @__PURE__ */ new Set()) {
+	const { pieces: _, ...comparison } = await comparing(page, earlier, round, unsteady);
+	return comparison;
+}
+function unsteadyIn(flows) {
+	const everywhere = flows.flatMap((flow) => (flow.unsteady ?? []).filter((piece) => !piece.startsWith(HERE)));
+	const here = (name) => flows.filter((flow) => flow.name === name).flatMap((flow) => (flow.unsteady ?? []).filter((piece) => piece.startsWith(HERE)).map((piece) => piece.slice(5)));
+	return (name) => /* @__PURE__ */ new Set([...everywhere, ...here(name)]);
+}
+async function comparing(page, earlier, round, unsteady = () => /* @__PURE__ */ new Set()) {
 	const changes = /* @__PURE__ */ new Map();
-	const see = ({ id, words, place }) => {
-		if (unsteady.has(id)) return;
+	const pieces = /* @__PURE__ */ new Map();
+	const see = ({ id, words, place, of = [id] }) => {
+		if (unsteady(place.flow).has(id)) return;
 		const change = changes.get(id);
+		for (const piece of of) (pieces.get(id) ?? pieces.set(id, /* @__PURE__ */ new Set()).get(id)).add(piece);
 		if (!change) changes.set(id, {
 			id,
 			words,
@@ -1949,7 +1735,7 @@ async function compare(page, earlier, round, unsteady = /* @__PURE__ */ new Set(
 	};
 	for (const flow of round.flows) {
 		const before = earlier.flows.find((kept) => kept.name === flow.name);
-		if (before) for (const sighting of await compareFlow(page, earlier, before, round, flow, unsteady)) see(sighting);
+		if (before) for (const sighting of await compareFlow(page, earlier, before, round, flow, unsteady(flow.name))) see(sighting);
 	}
 	for (const gone of earlier.flows.filter((flow) => !round.flows.some((kept) => kept.name === flow.name))) see({
 		id: idOf(`flow:${gone.name}`, "gone"),
@@ -1959,7 +1745,8 @@ async function compare(page, earlier, round, unsteady = /* @__PURE__ */ new Set(
 	return {
 		round: round.number,
 		since: earlier.number,
-		changes: [...changes.values()]
+		changes: [...changes.values()],
+		pieces
 	};
 }
 async function compareFlow(page, earlier, before, round, flow, unsteady) {
@@ -1994,7 +1781,8 @@ async function compareFlow(page, earlier, before, round, flow, unsteady) {
 					flow: flow.name,
 					at: reading.at,
 					...on
-				}
+				},
+				of: found.pieces
 			});
 		}
 	}
@@ -2057,171 +1845,141 @@ function runs(count, isIn) {
 	}
 	return found;
 }
-// ../review/src/folder.ts
-const LOOK_EVERY = 2e3;
-function folder(root) {
-	return {
-		async read(path) {
-			try {
-				return new Uint8Array(await readFile(join(root, path)));
-			} catch (error) {
-				if (isMissing(error)) return void 0;
-				throw error;
+// src/try-setup.ts
+const SLOW = 2e3;
+async function trySetup(repo, again) {
+	const app = await repo.app();
+	const written = await writtenNow(repo);
+	const last = join(repo.tried, "tried.json");
+	if (await readFile(last, "utf8").then((text) => JSON.parse(text).written, () => void 0) === written) return;
+	console.log("Trying the app's setup by itself first, twice, as every flow will start…");
+	const browser = await chromium.launch().catch((error) => {
+		const { version } = createRequire(import.meta.url)("@playwright/test/package.json");
+		if (/Executable doesn't exist/.test(String(error?.message))) throw new Refused([`Playwright has no Chromium to run the flows in yet. Install the one Playthrough's Playwright runs (npx playwright@${version} install chromium), then run this again.`]);
+		throw error;
+	});
+	let startedIn;
+	let setup;
+	const tried = [];
+	try {
+		startedIn = await keepRunning(app, repo.root);
+		setup = await setupIn(repo.setup, (await stat(repo.setup).catch(() => void 0))?.mtimeMs);
+		await giveBackLeft(setup, repo.borrowed);
+		await rm(repo.tried, {
+			recursive: true,
+			force: true
+		});
+		await mkdir(repo.tried, { recursive: true });
+		const people = Object.keys(setup.people ?? {});
+		for (const person of people.length ? people : [void 0]) tried.push(await tryAs(repo, browser, setup, app.url, person));
+	} finally {
+		await browser.close();
+	}
+	const width = Math.max(7, ...tried.map(({ who }) => who.length)) + 3;
+	const line = (label, said) => `  ${label.padEnd(width)}${said}`;
+	console.log(`\n${line("The app", startedIn === void 0 ? `running already at ${app.url}` : `started with ${quote(app.start)}, answering at ${app.url} in ${seconds(startedIn)}`)}`);
+	for (const { who, did, took, at, refused, picture } of tried) console.log(line(who, `${did}${did === "nothing made" ? "" : ` in ${seconds(took)}`}, then at ${at}${refused ? `, which the app answered with ${refused}` : ""}: ${repo.show(picture)}`));
+	const missing = [];
+	if (!setup.after && tried.some(({ made }) => made)) missing.push("playthrough/setup.ts has no after, so what each run makes stays in the app: one for each flow recorded, two for a new one, and one each time the person pauses a recording, as it's made ready to take over.");
+	else if (tried.some(({ givenBack }) => !givenBack)) missing.push("playthrough/setup.ts's after couldn't give back what it made, for the reason above.");
+	const slowest = Math.max(...tried.map(({ took }) => took));
+	if (slowest > SLOW) missing.push(`Setup took ${seconds(slowest)}: each flow waits that long before its first step, and so does each moment taken over.`);
+	console.log(`
+Look at ${tried.length > 1 ? "each picture: it's where their flows start" : "the picture: it's where every flow starts"}. One that shows a sign-in page for someone who should be signed in, or anything a flow shouldn't start from, is for playthrough/setup.ts.`);
+	if (missing.length) console.log(`
+${missing.map((said) => `- ${said}`).join("\n")}
+
+Tell the person now, in a few lines, how flows get into their app, and for each of these, what it costs them and the step that would fix it: something the app has already, or something only they can give, like a test account. Ask before you change their app for it, as with a route only for tests, and don't wait for their answer.`);
+	else console.log(`\nTell the person in a line or two how flows get into their app.`);
+	await writeFile(last, JSON.stringify({ written }));
+	throw new Refused([`\nNothing's recorded yet. Once ${tried.length > 1 ? "each picture shows" : "the picture shows"} where a flow should start, run ${again} again.`]);
+}
+async function tryAs(repo, browser, setup, baseURL, person) {
+	const tried = {
+		who: person ? person.charAt(0).toUpperCase() + person.slice(1) : "Every flow",
+		did: setup.make && person && setup.signIn ? "made and signed in" : setup.make ? "made" : person && setup.signIn ? "signed in" : "nothing made",
+		took: 0,
+		at: "",
+		picture: join(repo.tried, `${(person ?? "every flow").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "person"}.png`),
+		made: false,
+		givenBack: true
+	};
+	for (const time of ["first", "second"]) {
+		const context = await browser.newContext({
+			...setup.use,
+			baseURL,
+			locale: "en-US",
+			timezoneId: "UTC",
+			viewport: {
+				width: 1280,
+				height: 800
 			}
-		},
-		async write(path, bytes) {
-			const file = join(root, path);
-			const unfinished = `${file}.${process.pid}.${Date.now()}.writing`;
-			await mkdir(dirname(file), { recursive: true });
-			await writeFile(unfinished, bytes);
-			await rename(unfinished, file);
-		},
-		async list(path) {
+		});
+		const page = await context.newPage();
+		const request$1 = await request.newContext({ baseURL });
+		let made;
+		let answered;
+		page.on("response", (response) => void (response.request().isNavigationRequest() && response.frame() === page.mainFrame() && (answered = response)));
+		try {
+			const began = Date.now();
+			const sent = (sent) => void (changes(sent.method()) && (tried.made = true));
+			page.on("request", sent);
 			try {
-				return (await readdir(join(root, path))).filter((name) => !name.endsWith(".writing"));
+				made = await make(setup, repo.borrowed, {
+					page,
+					request: watching(request$1, () => tried.made = true),
+					baseURL,
+					person
+				});
+				page.off("request", sent);
+				if (Object.keys(made.setup).length) tried.made = true;
+				if (person) await setup.signIn?.({
+					page,
+					person,
+					setup: made.setup
+				});
 			} catch (error) {
-				if (isMissing(error)) return [];
-				throw error;
+				const why = firstLine(String(error?.message ?? error));
+				const as = person ? ` for ${quote(person)}` : "";
+				throw new Refused([time === "first" ? `playthrough/setup.ts couldn't make what a flow starts from${as}: ${why}. Fix it and run this again.` : `playthrough/setup.ts made what a flow starts from${as} once, but not a second time: ${why}. Each run makes its own, so make it new each time, as with a name or an email of its own, and run this again.`]);
 			}
-		},
-		watch(path, changed) {
-			const look = setInterval(changed, LOOK_EVERY);
-			let watcher;
-			try {
-				watcher = watch(join(root, path), { recursive: true }, changed);
-				watcher.on("error", () => watcher?.close());
-			} catch {}
-			return () => {
-				clearInterval(look);
-				watcher?.close();
-			};
+			tried.took = Math.max(tried.took, Date.now() - began);
+			if (page.url() === "about:blank") await page.goto("/");
+			await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {});
+			const url = new URL(page.url());
+			tried.at = url.origin === new URL(baseURL).origin ? `${url.pathname}${url.search}` : url.href;
+			tried.refused = answered && answered.status() >= 400 ? `${answered.status()} ${answered.statusText()}`.trim() : void 0;
+			if (time === "second") await page.screenshot({ path: tried.picture });
+		} finally {
+			await context.close();
+			await request$1.dispose();
+			if (made && setup.after && !await made.giveBack()) tried.givenBack = false;
 		}
-	};
-}
-const isMissing = (error) => error.code === "ENOENT";
-// src/repo.ts
-function repo(root = process.cwd()) {
-	const reviews = join(root, ".playthrough");
-	return {
-		root,
-		reviews: new Reviews(folder(reviews)),
-		flows: (review) => join(reviews, review, "flows"),
-		failed: (review) => join(reviews, review, "failed"),
-		round: (review, round) => join(reviews, review, "rounds", String(round), "round.json"),
-		setAside: join(reviews, "set-aside.json"),
-		setup: join(root, "playthrough", "setup.ts"),
-		borrowed: join(reviews, "borrowed"),
-		show: (path) => relative(process.cwd(), path) || ".",
-		async keepOutOfGit() {
-			await mkdir(reviews, { recursive: true });
-			await writeFile(join(reviews, ".gitignore"), "*\n");
-		},
-		async app() {
-			const file = join(root, "playthrough", "app.json");
-			const how = `Say how to start the app in playthrough/app.json: { "start": "<the command that serves it>", "url": "<where it's served>" }.`;
-			const text = await readFile(file, "utf8").catch(() => void 0);
-			if (text === void 0) throw new Refused([`Playthrough needs to start the app to record it. ${how}`]);
-			let app;
-			try {
-				app = JSON.parse(text);
-			} catch (error) {
-				throw new Refused([`playthrough/app.json isn't JSON: ${error.message}. ${how}`]);
-			}
-			if (!isText(app.start) || !isText(app.url)) throw new Refused([`playthrough/app.json needs both “start” and “url”. ${how}`]);
-			return {
-				start: app.start,
-				url: app.url
-			};
-		}
-	};
-}
-const isText = (value) => typeof value === "string" && value.trim() !== "";
-// src/setup.ts
-async function setupIn(file, written) {
-	if (!existsSync(file)) return {};
-	const module = await import(`${pathToFileURL(file).href}${written ? `?${written}` : ""}`);
-	const inner = typeof module.default === "object" ? module.default : void 0;
-	return {
-		make: typeof module.default === "function" ? module.default : inner?.default,
-		after: module.after ?? inner?.after,
-		signIn: module.signIn ?? inner?.signIn,
-		people: module.people ?? inner?.people
-	};
-}
-const firstOf = ({ people }) => Object.keys(people ?? {})[0];
-function personIn({ people }, person) {
-	if (people && !(person in people)) throw new Error(`playthrough/setup.ts names no one called ${quote(person)}. Its people: ${list(Object.keys(people).map(quote))}. Add them there, or do the flow as one of them.`);
-}
-async function make({ make, after }, borrowed, given) {
-	const setup = await make?.(given) ?? {};
-	if (!after) return {
-		setup,
-		giveBack: async () => {}
-	};
-	await mkdir(borrowed, { recursive: true });
-	const file = join(borrowed, `${process.pid}-${randomUUID()}.json`);
-	await writeFile(file, JSON.stringify({
-		baseURL: given.baseURL,
-		setup
-	}));
-	return {
-		setup,
-		giveBack: () => giveBack(after, file, given.baseURL, setup)
-	};
-}
-const giveBackLeft = (setup, borrowed) => giveBackOf(setup, borrowed, (pid) => !alive(pid));
-const giveBackOwn = (setup, borrowed) => giveBackOf(setup, borrowed, (pid) => pid === process.pid);
-async function giveBackOf({ after }, borrowed, whose) {
-	if (!after) return;
-	const left = (await readdir(borrowed).catch(() => [])).filter((name) => whose(Number(name.split("-")[0])));
-	for (const name of left) {
-		const file = join(borrowed, `${process.pid}-${name.slice(name.indexOf("-") + 1)}`);
-		if (!await rename(join(borrowed, name), file).then(() => true, () => false)) continue;
-		const { baseURL, setup } = JSON.parse(await readFile(file, "utf8"));
-		await giveBack(after, file, baseURL, setup);
 	}
+	return tried;
 }
-const giving = /* @__PURE__ */ new Set();
-async function giveBack(after, file, baseURL, setup) {
-	if (giving.has(file) || !existsSync(file)) return;
-	giving.add(file);
-	const request$1 = await request.newContext({ baseURL });
-	try {
-		await after({
-			request: request$1,
-			baseURL,
-			setup
-		});
-		await rm(file, { force: true });
-	} catch (error) {
-		console.log(`playthrough/setup.ts's after couldn't give back what a run made: ${firstLine(String(error?.message ?? error))}. It's tried again by the next command.`);
-	} finally {
-		giving.delete(file);
-		await request$1.dispose();
-	}
-}
-function alive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		return error.code === "EPERM";
-	}
+const seconds = (ms) => ms < 100 ? "under 0.1 s" : `${(ms / 1e3).toFixed(1)} s`;
+async function writtenNow(repo) {
+	const text = (path) => readFile(path, "utf8").catch(() => "");
+	return createHash("sha256").update(await text(repo.appFile)).update("\0").update(await text(repo.setup)).digest("hex");
 }
 // src/flows.ts
 const WALKED = "walked.json";
 const ALONGSIDE = Symbol.for("playthrough: flows taken over here");
 const REACHES_OUTSIDE = "reaches outside";
+const waitsFor = ({ before }) => before ? 3e3 : 1e4;
 async function makeFlowsFolder(repo, id) {
 	await mkdir(repo.flows(id), { recursive: true });
 	await writeFile(join(repo.flows(id), "package.json"), `{ "type": "module" }\n`, { flag: "wx" }).catch((error) => {
 		if (error.code !== "EEXIST") throw error;
 	});
 }
+const called = (names) => names.length > 3 ? `${names.length} flows` : list(names.map(quote));
 const isFlow = (name) => /\.[cm]?[jt]s$/.test(name);
 function howToWriteFlows(repo, id) {
 	const setupMissing = !existsSync(repo.setup);
-	return `Each flow is a Playwright test in ${repo.show(repo.flows(id))}, one for each thing a person does, with a step for each part of it:
+	const missing = !existsSync(repo.appFile) ? `, and how to start the app in playthrough/app.json. This app has ${setupMissing ? "neither" : "no app.json"} yet: run playthrough alone for how. Playthrough tries them before it records anything.` : setupMissing ? ", which this app doesn't have yet: run playthrough alone for how." : ".";
+	return `Each flow is a Playwright test in a .ts file in ${repo.show(repo.flows(id))}, one for each thing a person does, with a step for each part of it:
 
   import { test, expect } from "playthrough/test";
 
@@ -2235,17 +1993,18 @@ function howToWriteFlows(repo, id) {
   });
 
 The test's name is the flow's, and steps are matched across rounds by their names. What every flow starts from, like
-the account it opens, is made in playthrough/setup.ts${setupMissing ? ", which this app doesn't have yet" : ""}: run playthrough alone for how.`;
+the account it opens, is made in playthrough/setup.ts${missing}`;
 }
 async function runFlows(repo, id, round, { later, first }) {
 	const flows = repo.flows(id);
 	if (!(await readdir(flows).catch(() => [])).some(isFlow)) throw new Refused([`${id} has no flows yet. ${howToWriteFlows(repo, id)}`]);
 	await makeFlowsFolder(repo, id);
 	const app = await repo.app();
+	if (!later) await trySetup(repo, round === 0 ? `playthrough start ${id}` : `playthrough record ${id}`);
 	const { started, rounds } = await repo.reviews.get(id);
 	const recorder = join(dirname(createRequire(import.meta.url).resolve("@rrweb/record")), "record.umd.min.cjs");
 	const longest = (rounds.filter((kept) => kept.number < round).at(-1)?.flows ?? []).toSorted((a, b) => b.length - a.length).map((flow) => flow.name);
-	const run = (only, results) => runOnce({
+	const run = (only, results, stops) => runOnce({
 		flows,
 		only,
 		longest,
@@ -2255,44 +2014,63 @@ async function runFlows(repo, id, round, { later, first }) {
 		recorder,
 		before: round === 0,
 		taken: later?.taken ?? [],
-		started
+		started,
+		stops
 	});
 	const last = round > 0 ? await failedLastTime(repo, id) : [];
 	if (last.length) {
-		console.log(`Running ${list(last.map(quote))} first: ${last.length > 1 ? "they" : "it"} failed last time…`);
-		const { failed } = await run(last, repo.failed(id));
+		console.log(`Running ${called(last)} first: ${last.length > 1 ? "they" : "it"} failed last time…`);
+		const { recorded, failed } = await run(last, repo.failed(id));
 		await keepFailed(repo, id, round, failed);
 		const [one] = failed;
 		if (failed.length > 1) throw new Refused([
-			`These flows failed again, so the other flows weren't run:`,
+			`\nThese flows failed again, so the other flows weren't run:`,
 			...failed.map(failedAt),
 			`Fix them and record again. ${whereItStopped(repo, id, failed)}`
 		]);
-		if (one) throw new Refused([`${quote(one.flow)} failed again${one.at ? `, at the step ${quote(one.at)}` : ""}, so the other flows weren't run.`, `Fix it and record again. ${whereItStopped(repo, id, failed)}`]);
-		console.log(`\n${last.length > 1 ? "They pass" : "It passes"} now, so every flow is recorded.\n`);
+		if (one) throw new Refused([`\n${quote(one.flow)} failed again${one.at ? `, at the step ${quote(one.at)}` : ""}, so the other flows weren't run.`, `Fix it and record again. ${whereItStopped(repo, id, failed)}`]);
+		const gone = !recorded.length;
+		console.log(`\n${last.length > 1 ? gone ? "They aren't flows any more" : "They pass now" : gone ? "It isn't a flow any more" : "It passes now"}, so every flow is recorded.\n`);
 	}
-	console.log(later ? `Recording ${list(later.flows.map(quote))} on Before, the app as it was…` : round === 0 ? `Recording Before: each flow of ${id} on the app as it is…` : `Recording round ${round} of ${id}…`);
+	console.log(later ? `Recording ${called(later.flows)} on Before, the app as it was…` : round === 0 ? `Recording Before: each flow of ${id} on the app as it is…` : `Recording round ${round} of ${id}…`);
 	const once = await run(later?.flows, repo.failed(id));
 	await keepFailed(repo, id, round, once.failed);
 	const again = once.recorded.filter(({ flow }) => first(flow.name));
 	if (!again.length || round > 0 && once.failed.length) return once;
-	console.log(`\nRecording ${list(again.map(({ flow }) => quote(flow.name)))} again, to see what changes by itself…`);
-	const twice = await run(once.failed.length ? later?.flows : again.map(({ flow }) => flow.name), repo.failed(id));
-	await keepFailed(repo, id, round, twice.failed);
+	console.log(`\nRecording ${called(again.map(({ flow }) => flow.name))} again, to see what changes by itself…`);
+	const stops = Object.fromEntries(once.failed.flatMap(({ flow, at }) => at ? [[flow, at]] : []));
+	const results = once.failed.length ? void 0 : repo.failed(id);
+	const twice = await run(again.map(({ flow }) => flow.name), results, stops);
+	if (results) await keepFailed(repo, id, round, twice.failed);
 	const unlike = again.filter(({ flow }) => {
 		const failed = (ran) => ran.failed.find((failure) => failure.flow === flow.name)?.at;
 		return !twice.recorded.some((kept) => kept.flow.name === flow.name) || failed(once) !== failed(twice);
 	});
-	if (unlike.length) throw new Refused([`${list(unlike.map(({ flow }) => quote(flow.name)))} didn't go the same way twice on the same app, so ${unlike.length > 1 ? "they don't" : "it doesn't"} start from the same place each time. Make what every flow starts from in playthrough/setup.ts, the same each time, and run this again.`]);
+	if (unlike.length) throw new Refused([
+		`\n${list(unlike.map(({ flow }) => quote(flow.name)))} didn't go the same way twice on the same app:`,
+		...unlike.map(({ flow }) => `  ${quote(flow.name)}: the first time, ${went(once, flow.name)}; the second, ${went(twice, flow.name)}.`),
+		`So ${unlike.length > 1 ? "they don't" : "it doesn't"} start from the same place each time. ${app.oneAtATime ? "Make what every flow starts from in playthrough/setup.ts, the same each time and new for each run, and run this again." : `Flows run several at once on the one app, so what one makes, another can meet: make what every flow starts from in playthrough/setup.ts, the same each time and new for each run. Where a page shows what every run made, as a blog's index lists every post, say "oneAtATime": true in playthrough/app.json instead. Then run this again.`}`
+	]);
 	const byThemselves = await changesByThemselves(inMemory(round, again), inMemory(round, twice.recorded.filter(({ flow }) => first(flow.name))));
 	for (const { flow } of again) {
 		const unsteady = byThemselves.filter((change) => change.seen.some((place) => place.flow === flow.name));
 		if (!unsteady.length) continue;
-		flow.unsteady = unsteady.map((change) => change.id);
-		console.log(`\nIn ${quote(flow.name)}, this changes by itself, so it's left out of every comparison, in every flow:\n${unsteady.map((change) => `  ${change.words}`).join("\n")}\nIf it can be made the same each time, in playthrough/setup.ts, do that and record again: a real change to it won't be seen.`);
+		flow.unsteady = [...new Set(unsteady.flatMap((change) => change.pieces))];
+		const here = unsteady.filter((change) => change.pieces.every((piece) => piece.startsWith(HERE)));
+		const everywhere = unsteady.filter((change) => !here.includes(change));
+		const listed = (changes) => changes.map((change) => `  ${change.words}`).join("\n");
+		if (everywhere.length) console.log(`\nIn ${quote(flow.name)}, this changes by itself, so it's left out of every comparison, in every flow:\n${listed(everywhere)}`);
+		if (here.length) console.log(`\nIn ${quote(flow.name)}, this part of a picture changes by itself, so it's left out of this flow's comparisons, where it's known only by its place:\n${listed(here)}`);
+		console.log("If it can be made the same each time, in playthrough/setup.ts, do that and record again: a real change to it won't be seen.");
 	}
 	return once;
 }
+function went(ran, name) {
+	const failure = ran.failed.find((failed) => failed.flow === name);
+	if (!failure) return "it went to its end";
+	const because = failure.why ? `, where Playwright says “${failure.why}”` : "";
+	return failure.at ? `it stopped at ${quote(failure.at)}${because}` : `it stopped before its first step${because}`;
+}
 async function keepFailed(repo, id, round, failed) {
 	const folder = repo.failed(id);
 	if (!failed.length) return rm(folder, {
@@ -2333,21 +2111,24 @@ async function runOnce(run) {
 			folder
 		});
 		const text = await readFile(join(folder, "flows.json"), "utf8").catch(() => void 0);
-		const { recorded, failed } = text ? JSON.parse(text) : {
+		const { recorded, failed, written } = text ? JSON.parse(text) : {
 			recorded: [],
-			failed: []
+			failed: [],
+			written: {}
 		};
-		if (!ran && !failed.length) throw new Refused(["The flows didn't run, for the reason Playwright gives above. Fix that and run this again."]);
-		const withFiles = ({ flow, files }) => Promise.all(files.map(async (name) => ({
+		if (!ran && !failed.length) throw new Refused(["\nThe flows didn't run, for the reason Playwright gives above. Fix that and run this again."]);
+		const withFiles = ({ flow, files, wrote }) => Promise.all(files.map(async (name) => ({
 			name,
 			bytes: await readFile(join(folder, name))
 		}))).then((files) => ({
 			flow,
-			files
+			files,
+			...wrote && { wrote }
 		}));
 		return {
 			recorded: await Promise.all(recorded.map(withFiles)),
-			failed
+			failed,
+			written
 		};
 	} finally {
 		await rm(folder, { recursive: true });
@@ -2390,15 +2171,16 @@ async function walkFork(repo, id, walk) {
 		});
 	}
 }
-const failedAt = ({ flow, at }) => `  ${quote(flow)}${at ? `, at the step ${quote(at)}` : ""}`;
+const failedAt = ({ flow, at, why }) => `  ${quote(flow)}${at ? `, at the step ${quote(at)}` : ""}${why ? `, where Playwright says “${why}”` : ""}`;
 async function playwright(run) {
-	const { setup, borrowed } = repo(run.root);
-	await giveBackLeft(await setupIn(setup), borrowed);
 	try {
 		createRequire(join(run.root, "package.json")).resolve("playthrough/test");
 	} catch {
 		throw new Refused(["Playthrough isn't installed in this app, so its flows can't import playthrough/test. Install it as a dev dependency (npm install --save-dev playthrough), then run this again."]);
 	}
+	await keepRunning(run.app, run.root);
+	const { setup, borrowed } = repo(run.root);
+	await giveBackLeft(await setupIn(setup), borrowed);
 	const cli = createRequire(import.meta.url).resolve("@playwright/test/cli");
 	const config = fileURLToPath(new URL("./playwright.config.js", import.meta.url));
 	return new Promise((resolve, reject) => {
@@ -2424,237 +2206,4 @@ async function playwright(run) {
 		});
 	});
 }
-// src/read.ts
-function readPage(page) {
-	return page.evaluate(read);
-}
-async function unhovered(page, look) {
-	await page.evaluate(hovering, false);
-	try {
-		return await look();
-	} finally {
-		await page.evaluate(hovering, true);
-	}
-}
-function hovering(on) {
-	const kept = window;
-	if (on) {
-		for (const [rule, selector] of kept.__playthroughHover ?? []) rule.selectorText = selector;
-		kept.__playthroughHover = [];
-		return;
-	}
-	const set = kept.__playthroughHover = [];
-	const visit = (rules) => {
-		for (const rule of rules) {
-			if (rule instanceof CSSStyleRule && rule.selectorText.includes(":hover")) {
-				set.push([rule, rule.selectorText]);
-				rule.selectorText = rule.selectorText.replaceAll(":hover", ":not(*)");
-			}
-			if ("cssRules" in rule) visit(rule.cssRules);
-		}
-	};
-	for (const sheet of [...document.styleSheets, ...document.adoptedStyleSheets]) try {
-		visit(sheet.cssRules);
-	} catch {}
-	getComputedStyle(document.body).color;
-	for (const animation of document.getAnimations()) if (animation instanceof CSSTransition) animation.finish();
-}
-function read() {
-	const ROLES = /^(button|link|dialog|alertdialog|group|radiogroup|table|grid|treegrid|heading|status|alert|textbox|searchbox|combobox|checkbox|radio|switch|slider|listbox|option|tab|menu|menuitem|img)$/;
-	const HOLDERS = /^(dialog|alertdialog|status|alert|group|radiogroup|table|grid|treegrid|listbox|menu|box)$/;
-	const NAMED_BY_WORDS = /^(button|link|heading|option|tab|menuitem|radio|checkbox|switch)$/;
-	const MARKED = /^(B|STRONG|I|EM|U|S|MARK|SMALL|CODE|KBD|SPAN|ABBR|TIME|SUB|SUP|Q|DATA|VAR|DEL|INS|BDI|CITE|DFN)$/;
-	const INPUTS = {
-		checkbox: "checkbox",
-		radio: "radio",
-		range: "slider",
-		button: "button",
-		submit: "button",
-		reset: "button",
-		search: "searchbox"
-	};
-	const TAGS = {
-		BUTTON: "button",
-		SUMMARY: "button",
-		DIALOG: "dialog",
-		TABLE: "table",
-		SELECT: "combobox",
-		TEXTAREA: "textbox",
-		OUTPUT: "status",
-		FIELDSET: "group",
-		IMG: "img",
-		H1: "heading",
-		H2: "heading",
-		H3: "heading",
-		H4: "heading",
-		H5: "heading",
-		H6: "heading"
-	};
-	const TABLES = "table, [role=table], [role=grid], [role=treegrid]";
-	const mirror = window.rrwebRecord?.record?.mirror;
-	const plain = (words) => words.replace(/\s+/g, " ").trim();
-	const cut = (words, most) => words.length > most ? words.slice(0, most - 1).trimEnd() + "…" : words;
-	const style = (element) => getComputedStyle(element);
-	function roleOf(element) {
-		const given = element.getAttribute("role")?.trim().split(/\s+/)[0];
-		if (given) return given;
-		if (element.tagName === "A") return element.hasAttribute("href") ? "link" : void 0;
-		if (element.tagName === "INPUT") {
-			const type = (element.getAttribute("type") ?? "text").toLowerCase();
-			return type === "hidden" ? void 0 : INPUTS[type] ?? "textbox";
-		}
-		return TAGS[element.tagName];
-	}
-	const apart = (element, side) => {
-		const looks = style(element);
-		return !looks.display.startsWith("inline") || parseFloat(looks[`margin${side}`]) + parseFloat(looks[`padding${side}`]) > 0 ? " " : "";
-	};
-	function spoken(element) {
-		let words = "";
-		for (const node of element.childNodes) if (node.nodeType === Node.TEXT_NODE) words += node.textContent;
-		else if (node instanceof HTMLBRElement) words += " ";
-		else if (node instanceof Element) words += apart(node, "Left") + spoken(node) + apart(node, "Right");
-		return words;
-	}
-	function ownWords(element) {
-		let words = "";
-		for (const node of element.childNodes) if (node.nodeType === Node.TEXT_NODE) words += node.textContent;
-		else if (node instanceof Element && MARKED.test(node.tagName) && !called(node) && !panel(node)) {
-			const looks = style(node);
-			if (looks.display === "none" || looks.visibility === "hidden") continue;
-			words += apart(node, "Left") + ownWords(node) + apart(node, "Right");
-		}
-		return plain(words);
-	}
-	const labelOf = (element) => {
-		const by = element.getAttribute("aria-labelledby");
-		return plain(by ? by.split(/\s+/).map((id) => document.getElementById(id)?.textContent ?? "").join(" ") : element.getAttribute("aria-label") ?? "");
-	};
-	function nameOf(element, role) {
-		let name = labelOf(element);
-		if (!name && NAMED_BY_WORDS.test(role)) name = plain(spoken(element));
-		if (!name && "labels" in element) name = plain([...element.labels ?? []].map((label) => label.textContent).join(" "));
-		if (!name) name = element.getAttribute("alt") ?? element.getAttribute("title") ?? element.getAttribute("placeholder") ?? "";
-		return cut(plain(name), 120);
-	}
-	function called(element) {
-		const role = roleOf(element);
-		if (!role || !ROLES.test(role)) return void 0;
-		const name = nameOf(element, role);
-		return /group$/.test(role) && !name ? void 0 : {
-			role,
-			name
-		};
-	}
-	const labelledPart = (element) => (/^(SECTION|ASIDE|NAV|FORM|ARTICLE)$/.test(element.tagName) || /^(region|form|navigation|complementary|search|article)$/.test(element.getAttribute("role") ?? "")) && !!labelOf(element);
-	function panel(element) {
-		const box = element.getBoundingClientRect();
-		if (box.width < 12 || box.height < 12 || box.width * box.height > .9 * innerWidth * innerHeight) return false;
-		if (/^(HTML|BODY|MAIN|TR|TBODY|THEAD|TD|TH)$/.test(element.tagName)) return false;
-		if (labelledPart(element)) return true;
-		const looks = style(element);
-		const background = looks.backgroundColor;
-		const around = element.parentElement && style(element.parentElement).backgroundColor;
-		if (!/^(transparent|rgba\(0, 0, 0, 0\))$/.test(background) && background !== around) return true;
-		if (looks.boxShadow !== "none") return true;
-		return [
-			"Top",
-			"Right",
-			"Bottom",
-			"Left"
-		].filter((side) => parseFloat(looks[`border${side}Width`]) > 0 && looks[`border${side}Style`] !== "none").length >= 3;
-	}
-	const firstWords = (element) => {
-		const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
-		for (let node; node = walker.nextNode();) if (plain(node.textContent ?? "")) return plain(node.textContent ?? "");
-		return "";
-	};
-	const allWords = (element) => {
-		const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
-		const words = [];
-		for (let node; node = walker.nextNode();) words.push(node.textContent ?? "");
-		return plain(words.join(" "));
-	};
-	function headingsOf(table) {
-		const cells = [...table.querySelectorAll("th, [role=columnheader]")].filter((cell) => cell.closest(TABLES) === table);
-		const row = cells[0]?.parentElement;
-		const headings = cells.filter((cell) => cell.parentElement === row).map((cell) => {
-			const box = cell.getBoundingClientRect();
-			return {
-				name: cut(plain(spoken(cell)), 120),
-				from: box.left,
-				to: box.right,
-				bottom: box.bottom
-			};
-		}).filter((heading) => heading.name && heading.to > heading.from);
-		return headings.length ? headings : void 0;
-	}
-	const things = [];
-	function walk(element, holder, parent, headings) {
-		for (const child of element.children) {
-			const looks = style(child);
-			if (looks.display === "none" || looks.visibility === "hidden" || Number(looks.opacity) === 0) continue;
-			const box = child.getBoundingClientRect();
-			const under = child.matches(TABLES) ? headingsOf(child) : headings;
-			const own = plain([...child.childNodes].filter((node) => node.nodeType === Node.TEXT_NODE).map((node) => node.textContent).join(" "));
-			let known = called(child);
-			if (!known && !own && panel(child)) {
-				const name = labelOf(child) || firstWords(child);
-				if (name) known = {
-					role: "box",
-					name: cut(name, 120)
-				};
-			}
-			let inside = holder;
-			let readParent = parent;
-			if ((known || own) && box.width >= 1 && box.height >= 1) {
-				const middle = box.left + box.width / 2;
-				const column = headings?.find((heading) => middle >= heading.from && middle < heading.to && box.top >= heading.bottom - 2)?.name;
-				const node = mirror?.getId(child);
-				const words = cut(own ? ownWords(child) : "", 300);
-				const wordsInside = known && /^(box|menu)$/.test(known.role) ? cut(allWords(child), 300) : void 0;
-				things.push({
-					role: known?.role ?? "text",
-					name: known?.name ?? cut(words, 120),
-					words,
-					...wordsInside && wordsInside !== words && { wordsInside },
-					box: {
-						x: Math.round(box.left),
-						y: Math.round(box.top),
-						width: Math.round(box.width),
-						height: Math.round(box.height)
-					},
-					page: {
-						x: Math.round(box.left + scrollX),
-						y: Math.round(box.top + scrollY)
-					},
-					look: {
-						color: looks.color,
-						background: looks.backgroundColor,
-						size: looks.fontSize,
-						weight: looks.fontWeight,
-						border: parseFloat(looks.borderTopWidth) && looks.borderTopStyle !== "none" ? `${looks.borderTopWidth} ${looks.borderTopStyle} ${looks.borderTopColor}` : "none"
-					},
-					...holder !== void 0 && { holder },
-					...parent !== void 0 && { parent },
-					...column && { column },
-					...known?.role === "box" && labelOf(child) && { labelled: true },
-					...child.closest("[aria-live]:not([aria-live=\"off\"]), [role=\"status\"], [role=\"alert\"], [role=\"log\"]") && { live: true },
-					...node !== void 0 && node >= 0 && { node }
-				});
-				if (known && HOLDERS.test(known.role)) inside = things.length - 1;
-				readParent = things.length - 1;
-			}
-			walk(child, inside, readParent, under);
-		}
-	}
-	walk(document.body, void 0, void 0, void 0);
-	return {
-		screen: {
-			width: innerWidth,
-			height: innerHeight
-		},
-		things
-	};
-}
-export { problemsFinishing as A, shownAt as C, conversation as D, allNotes as E, list as M, quote as N, lastSeen as O, time as P, placeIn as S, pausedAt as T, make as _, REACHES_OUTSIDE as a, repo as b, howToWriteFlows as c, runFlows as d, walkFork as f, giveBackOwn as g, giveBackLeft as h, ALONGSIDE as i, roundInProgress as j, notesToAnswer as k, isFlow as l, firstOf as m, readPage as n, WALKED as o, whereItStopped as p, unhovered as r, failedAt as s, read as t, makeFlowsFolder as u, personIn as v, Refused as w, compareWithEarlier as x, setupIn as y };
+export { make as C, pausedAt as D, repo as E, giveBackLeft as S, setupIn as T, keepRunning as _, failedAt as a, changes as b, makeFlowsFolder as c, walkFork as d, whereItStopped as f, shownAt as g, placeIn as h, called as i, runFlows as l, compareWithEarlier as m, REACHES_OUTSIDE as n, howToWriteFlows as o, trySetup as p, WALKED as r, isFlow as s, ALONGSIDE as t, waitsFor as u, serves as v, personIn as w, firstOf$1 as x, stopApp as y };