playthrough 0.1.0 → 0.3.0

package/src/reporter-4C_7joIm.js

@@ -0,0 +1,919 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { z } from "zod";
+import { join, relative } from "node:path";
+import { createHash } from "node:crypto";
+// ../review/src/model.ts
+const text = (error) => z.string({ error }).refine((value) => value.trim() !== "", { error });
+const seconds$1 = (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 = 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 = "isn't on the screen. Boxes and points are shares of the screen, from 0 to 1";
+const Box = z.strictObject({
+	x: share(onScreen),
+	y: share(onScreen),
+	width: share(onScreen),
+	height: share(onScreen)
+}).refine((box) => box.x + box.width <= 1 && box.y + box.height <= 1, { error: onScreen });
+const Point = z.strictObject({
+	x: share(onScreen),
+	y: share(onScreen)
+});
+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$1("needs its moment, in seconds").optional().describe("Without it, the whole flow"),
+	until: seconds$1("needs its end, in seconds").optional().describe("The end of a stretch"),
+	element: Element.optional(),
+	alike: z.array(Element).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$1("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$1("needs the moment it starts, in seconds"),
+	actions: z.array(seconds$1("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(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(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, gone = []) {
+	const names = /* @__PURE__ */ new Set([
+		...flows.map((flow) => flow.name),
+		...cantStart,
+		...gone
+	]);
+	const again = new Map(flows.map((flow) => [flow.name, flow]));
+	return {
+		...before,
+		flows: [...before.flows.flatMap((flow) => again.has(flow.name) ? [again.get(flow.name)] : names.has(flow.name) ? [] : [flow]), ...flows.filter((flow) => !before.flows.some((kept) => kept.name === flow.name))],
+		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;
+}
+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(reply?.words)) problems.push(`${at} needs an answer to note ${id}${note ? `, “${cut(note.words)}”` : ""}: its reply's “words”, under “replies”.`);
+		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 > 140) problems.push(`${at}: the line on “${flow.name}” is ${flow.line.length} characters. Say it in a sentence of up to 140: 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(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(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$1[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$1[issue.expected] ?? issue.expected}`;
+	}
+	return field === void 0 ? "isn't right" : `has a ${field} that isn't right`;
+};
+const KINDS$1 = {
+	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(name) && `the flow “${name}”`,
+		steps: isText(title) && `the step “${title}”`,
+		changes: isText(words) && `the change “${cut(words)}”` || isText(id) && `the change ${id}`,
+		replies: isText(note) && `the reply to note ${note}`,
+		notes: isText(id) && `note ${id}`,
+		verdicts: isText(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(change.words)})`;
+const where = ({ seen: [first] }) => first ? `, in ${quote(first.flow)}${first.at === void 0 ? "" : ` at ${time(first.at)}`}` : "";
+const cut = (words) => words.length > 48 ? `${words.slice(0, 47).trimEnd()}…` : words;
+const isText = (value) => typeof value === "string" && value.trim() !== "";
+// ../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
+			};
+			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.`);
+			}
+			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, added.gone),
+				...added.commit && { commit: added.commit }
+			});
+		});
+	}
+	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);
+		});
+	}
+	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);
+		});
+	}
+	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()
+			});
+		});
+	}
+	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}`);
+	}
+	async files(id, round) {
+		const problems = problemsWithId(id);
+		if (problems.length || !Number.isInteger(round)) throw new Refused(problems.length ? problems : [`There's no round ${round}.`]);
+		return this.storage.list(`${id}/rounds/${round}/files`);
+	}
+	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();
+		});
+	}
+	#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();
+// src/assets.ts
+const assetsOf = (recording) => `assets/${recording}`;
+const KINDS = /* @__PURE__ */ new Set([
+	"font",
+	"image",
+	"stylesheet"
+]);
+const ENDINGS = {
+	"font/woff2": ".woff2",
+	"font/woff": ".woff",
+	"font/ttf": ".ttf",
+	"font/otf": ".otf",
+	"image/png": ".png",
+	"image/jpeg": ".jpg",
+	"image/gif": ".gif",
+	"image/webp": ".webp",
+	"image/avif": ".avif",
+	"image/svg+xml": ".svg",
+	"image/x-icon": ".ico",
+	"image/vnd.microsoft.icon": ".ico",
+	"text/css": ".css"
+};
+function keepAssets(page, folder) {
+	const kept = {};
+	const keeping = [];
+	mkdirSync(join(folder, "assets"), { recursive: true });
+	page.on("response", (response) => {
+		const address = response.url();
+		if (!KINDS.has(response.request().resourceType()) || response.status() !== 200 || address in kept) return;
+		kept[address] = "";
+		keeping.push(response.body().then((bytes) => {
+			const type = response.headers()["content-type"]?.split(";")[0]?.trim() ?? "";
+			const file = `assets/${createHash("sha256").update(bytes).digest("hex").slice(0, 16)}${ENDINGS[type] ?? ""}`;
+			writeFileSync(join(folder, file), bytes);
+			kept[address] = file;
+		}).catch(() => void delete kept[address]));
+	});
+	return async () => {
+		await Promise.all(keeping);
+		return Object.fromEntries(Object.entries(kept).filter(([, file]) => file));
+	};
+}
+// src/reporter.ts
+const RECORDING = "playthrough recording";
+const READINGS = "playthrough readings";
+const GLIMPSES = "playthrough glimpses";
+const PICTURE = "playthrough picture";
+const ASSETS = "playthrough assets";
+const PERSON = "playthrough person";
+const HANDS = "playthrough hands";
+const ACTIONS = "playthrough actions";
+const WROTE = "playthrough wrote";
+const UNMET = "playthrough unmet";
+const HOLD = 1500;
+const readingsOf = (flow) => `readings/${flow.recording}`;
+async function readingsOn(reviews, review, round, flow) {
+	const bytes = await reviews.file(review, round, readingsOf(flow));
+	return bytes ? JSON.parse(Buffer.from(bytes).toString()) : [];
+}
+const picturesOf = (flow) => `readings/${flow.recording.replace(/\.json$/, "")}`;
+const glimpsesOf = (flow) => `${picturesOf(flow)}.glimpses.json`;
+function firstLine(said) {
+	const lines = said.replace(/\x1b\[[0-9;]*m/g, "").split("\n");
+	let line = lines[0]?.trim().replace(/,$/, "") ?? "";
+	const waited = /Timeout \d+ms exceeded/.test(line) && lines.map((under) => under.match(/^\s*- (waiting for .+)$/)?.[1]).find(Boolean);
+	if (waited) line = `${line.replace(/\.$/, "")}, ${waited}`;
+	const found = line.endsWith(":") ? lines.flatMap((under) => under.match(/^\s*\d+\) .* aka (.+)$/)?.[1] ?? []) : [];
+	if (found.length) line = `${line} ${found.slice(0, 2).join(", ")}${found.length > 2 ? ", …" : ""}`;
+	return line.length > 300 ? `${line.slice(0, 300)}…` : line;
+}
+const BROKEN = /Page crashed|Target crashed|Target page, context or browser has been closed|net::ERR_CONNECTION_REFUSED/;
+const hashOf = (file) => {
+	try {
+		return createHash("sha256").update(readFileSync(file)).digest("hex");
+	} catch {
+		return;
+	}
+};
+var Flows = class {
+	#folder;
+	#flows;
+	#before;
+	#taken;
+	#ran = [];
+	constructor({ folder, flows, before, taken }) {
+		this.#folder = folder;
+		this.#flows = flows;
+		this.#before = before;
+		this.#taken = taken;
+	}
+	onTestEnd(test, result) {
+		if (result.status === "skipped") return;
+		const where = {
+			file: test.location.file,
+			line: test.location.line
+		};
+		const recording = result.attachments.find((attachment) => attachment.name === RECORDING)?.body;
+		const read = {
+			readings: JSON.parse(result.attachments.find((attachment) => attachment.name === "playthrough readings")?.body?.toString() ?? "[]"),
+			glimpses: JSON.parse(result.attachments.find((attachment) => attachment.name === "playthrough glimpses")?.body?.toString() ?? "[]"),
+			pictures: result.attachments.filter((attachment) => attachment.name === PICTURE).map((attachment) => attachment.body),
+			assets: JSON.parse(result.attachments.find((attachment) => attachment.name === "playthrough assets")?.body?.toString() ?? "{}"),
+			actions: JSON.parse(result.attachments.find((attachment) => attachment.name === "playthrough actions")?.body?.toString() ?? "[]"),
+			hands: JSON.parse(result.attachments.find((attachment) => attachment.name === "playthrough hands")?.body?.toString() ?? "[]")
+		};
+		const steps = result.steps.filter((step) => step.category === "test.step");
+		const person = result.attachments.find((attachment) => attachment.name === PERSON)?.body?.toString();
+		const wrote = result.attachments.find((attachment) => attachment.name === WROTE)?.body?.toString();
+		const as = (made) => {
+			if (person) made.flow.person = person;
+			for (const step of made.flow.steps) if (step.person === made.flow.person) delete step.person;
+			if (wrote) made.wrote = wrote;
+			return made;
+		};
+		const unmet = Number(result.attachments.find((attachment) => attachment.name === "playthrough unmet")?.body?.toString() ?? 0);
+		const yet = unmet ? `, though ${unmet > 1 ? `${unmet} things it expects aren't` : "1 thing it expects isn't"} so yet` : "";
+		const went = (how) => console.log(`  ${quote(test.title)}: ${how}`);
+		if (result.status === "passed") {
+			if (!recording) return;
+			const recorded = as(this.#flow(test.title, recording, read, steps));
+			this.#ran.push({
+				...where,
+				recorded
+			});
+			return went(`to its end, ${Math.round(recorded.flow.length)}s${yet}`);
+		}
+		const stop = steps.at(-1);
+		const kept = stop?.error ? steps.slice(0, -1) : steps;
+		const said = (stop?.error ?? result.error)?.message ?? "";
+		const broken = BROKEN.test(said);
+		const why = firstLine(said);
+		const failed = {
+			flow: test.title,
+			...stop?.error && { at: stop.title },
+			...why && { why },
+			...broken && { broken }
+		};
+		if (!this.#before || broken || !recording || !stop || !kept.length) {
+			this.#ran.push({
+				...where,
+				failed
+			});
+			return went(broken ? "the browser stopped it" : this.#before ? "can't start" : failed.at ? `failed at ${quote(failed.at)}` : "failed before its first step");
+		}
+		const until = stop.startTime.getTime() + (stop.error ? 0 : stop.duration);
+		const recorded = as(this.#flow(test.title, recording, read, kept, until));
+		if (stop.error) recorded.flow.stopped = stop.title;
+		this.#ran.push({
+			...where,
+			failed,
+			recorded
+		});
+		went(`${stop.error ? `stops at ${quote(stop.title)}` : "stops after its last step"}${yet}`);
+	}
+	onError(error) {
+		console.log(`\n${error.message ?? error.value}`);
+	}
+	#flow(name, recording, read, steps, until) {
+		let events = JSON.parse(recording.toString());
+		if (until !== void 0) events = [...events.filter((event) => event.timestamp < until), {
+			type: 5,
+			data: {
+				tag: "end",
+				payload: {}
+			},
+			timestamp: until + HOLD
+		}];
+		const start = events[0].timestamp;
+		const length = seconds(events.at(-1).timestamp - start);
+		const actionsIn = (step, next) => read.actions.filter((done) => done >= step.startTime.getTime() && done < (next?.startTime.getTime() ?? until ?? Infinity)).map((done) => Math.min(length, seconds(done - start)));
+		const flow = {
+			name,
+			length,
+			steps: steps.map((step, i) => {
+				const actions = actionsIn(step, steps[i + 1]);
+				const person = read.hands.filter((hand) => hand.at <= step.startTime.getTime()).at(-1)?.person;
+				return {
+					title: step.title,
+					at: Math.min(length, seconds(step.startTime.getTime() - start)),
+					...actions.length && { actions },
+					...person && { person }
+				};
+			}),
+			recording: this.#fileFor(name)
+		};
+		const readings = read.readings.map((reading, i) => ({
+			...reading,
+			picture: `${picturesOf(flow)}/${i + 1}.png`
+		}));
+		const glimpses = read.glimpses.filter((glimpse) => glimpse.at <= length);
+		const files = [
+			flow.recording,
+			readingsOf(flow),
+			glimpsesOf(flow),
+			...readings.map((reading) => reading.picture),
+			assetsOf(flow.recording),
+			...new Set(Object.values(read.assets))
+		];
+		for (const folder of [picturesOf(flow), "assets"]) mkdirSync(join(this.#folder, folder), { recursive: true });
+		writeFileSync(join(this.#folder, flow.recording), JSON.stringify(events));
+		writeFileSync(join(this.#folder, readingsOf(flow)), JSON.stringify(readings));
+		writeFileSync(join(this.#folder, glimpsesOf(flow)), JSON.stringify(glimpses));
+		writeFileSync(join(this.#folder, assetsOf(flow.recording)), JSON.stringify(read.assets));
+		read.pictures.forEach((picture, i) => writeFileSync(join(this.#folder, readings[i].picture), picture));
+		return {
+			flow,
+			files
+		};
+	}
+	onEnd() {
+		const ran = this.#ran.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+		const written = {};
+		for (const { file, recorded, failed } of ran) {
+			const hash = hashOf(file);
+			if (hash) written[recorded?.flow.name ?? failed.flow] = {
+				file: relative(this.#flows, file),
+				hash
+			};
+		}
+		writeFileSync(join(this.#folder, "flows.json"), JSON.stringify({
+			recorded: ran.flatMap((run) => run.recorded ?? []),
+			failed: ran.flatMap((run) => run.failed ?? []),
+			written
+		}));
+	}
+	printsToStdio() {
+		return true;
+	}
+	#fileFor(name) {
+		const base = name.toLowerCase().normalize("NFKD").replace(/['’]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "flow";
+		const taken = /* @__PURE__ */ new Set([...this.#taken, ...this.#ran.map((run) => run.recorded?.flow.recording)]);
+		for (let n = 1;; n++) {
+			const file = n === 1 ? `${base}.json` : `${base}-${n}.json`;
+			if (!taken.has(file)) return file;
+		}
+	}
+};
+const seconds = (ms) => Math.round(Math.max(0, ms)) / 1e3;
+export { time as A, conversation as C, roundInProgress as D, problemsFinishing as E, list as O, allNotes as S, notesToAnswer as T, readingsOn as _, HANDS as a, Refused as b, PICTURE as c, UNMET as d, WROTE as f, readingsOf as g, hashOf as h, GLIMPSES as i, quote as k, READINGS as l, glimpsesOf as m, ASSETS as n, HOLD as o, firstLine as p, Flows as r, PERSON as s, ACTIONS as t, RECORDING as u, seconds as v, lastSeen as w, Reviews as x, keepAssets as y };