playthrough 0.2.0 → 0.3.1

package/src/playthrough.js

@@ -1,44 +1,29 @@
 #!/usr/bin/env -S node --disable-warning=MODULE_TYPELESS_PACKAGE_JSON
-import { A as problemsFinishing, C as shownAt, D as conversation, E as allNotes, M as list, N as quote, O as lastSeen, P as time, S as placeIn, T as pausedAt, b as repo, c as howToWriteFlows, d as runFlows, f as walkFork, g as giveBackLeft, i as ALONGSIDE, j as roundInProgress, k as notesToAnswer, l as isFlow, m as keepRunning, p as whereItStopped, s as failedAt, t as read, u as makeFlowsFolder, w as Refused, x as compareWithEarlier, y as setupIn } from "./read-C9bKWxxP.js";
-import { d as firstLine, m as readingsOn } from "./reporter-CECNk7aW.js";
+import { A as problemsFinishing, C as Refused, D as inOrderJoined, E as conversation, M as list, N as quote, O as lastSeen, P as time, T as allNotes, _ as onPage, b as readingsOn, g as hashOf, j as roundInProgress, k as notesToAnswer, m as firstLine } from "./reporter-BEodHYRI.js";
+import { D as pausedAt, E as repo, S as giveBackLeft, T as setupIn, _ as keepRunning, a as failedAt, c as makeFlowsFolder, d as walkFork, f as whereItStopped, g as shownAt, h as placeIn, i as called, l as runFlows, m as compareWithEarlier, o as howToWriteFlows, p as trySetup, s as isFlow, t as ALONGSIDE, v as serves, y as stopApp } from "./flows-BcISV1M-.js";
+import { t as read } from "./read-Bg9XVTtn.js";
 import { createRequire } from "node:module";
-import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { copyFileSync, cpSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { constants, networkInterfaces, tmpdir, userInfo } from "node:os";
 import { dirname, extname, join, normalize, resolve, sep } from "node:path";
-import { readFile, readdir, stat } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
 import { chromium, request } from "@playwright/test";
+import { fileURLToPath } from "node:url";
 import { createServer, request as request$1 } from "node:http";
 import { connect } from "node:net";
+// src/node.ts
+const [major] = process.versions.node.split(".").map(Number);
+if (major < 24) {
+	console.error(`Playthrough needs Node 24 or later, and this is Node ${process.versions.node}. Install Node 24, then run this again.`);
+	process.exit(1);
+}
 // src/before.ts
 function keepBefore(repo, id) {
 	if (!attempt(() => git(repo, ["rev-parse", "--is-inside-work-tree"]))) return void 0;
 	try {
-		const tree = treeNow(repo);
-		const head = attempt(() => git(repo, [
-			"rev-parse",
-			"--verify",
-			"--quiet",
-			"HEAD"
-		]));
-		const commit = git(repo, [
-			"commit-tree",
-			"--no-gpg-sign",
-			...head ? ["-p", head] : [],
-			"-m",
-			`Before, of the review ${id}: the app as it was, with what wasn't committed`,
-			tree
-		], {
-			...process.env,
-			...PLAYTHROUGH
-		});
-		git(repo, [
-			"update-ref",
-			`refs/playthrough/${id}/before`,
-			commit
-		]);
-		return commit;
+		const head = headOf(repo);
+		return keep(repo, id, treeNow(repo), head ? [head] : []);
 	} catch (error) {
 		throw new Refused([
 			"Before can't be kept as a commit, because git says:",
@@ -47,29 +32,85 @@ function keepBefore(repo, id) {
 		]);
 	}
 }
-function treeNow(repo) {
+const keptWithOursNow = (repo, id, commit) => keep(repo, id, treeNow(repo, {
+	commit,
+	paths: ["playthrough"]
+}), git(repo, [
+	"rev-list",
+	"--parents",
+	"--max-count=1",
+	commit
+]).split(" ").slice(1));
+function keep(repo, id, tree, parents) {
+	const commit = git(repo, [
+		"commit-tree",
+		"--no-gpg-sign",
+		...parents.flatMap((parent) => ["-p", parent]),
+		"-m",
+		`Before, of the review ${id}: the app as it was, with what wasn't committed`,
+		tree
+	], {
+		...process.env,
+		...PLAYTHROUGH
+	});
+	git(repo, [
+		"update-ref",
+		`refs/playthrough/${id}/before`,
+		commit
+	]);
+	return commit;
+}
+function treeNow(repo, onto) {
 	const folder = mkdtempSync(join(tmpdir(), "playthrough-"));
 	try {
 		const index = join(folder, "index");
-		attempt(() => copyFileSync(resolve(repo.root, git(repo, [
-			"rev-parse",
-			"--git-path",
-			"index"
-		])), index));
 		const env = {
 			...process.env,
 			GIT_INDEX_FILE: index
 		};
-		git(repo, [
-			"add",
-			"--all",
-			":/"
-		], env);
+		if (onto) {
+			git(repo, ["read-tree", onto.commit], env);
+			git(repo, [
+				"rm",
+				"-r",
+				"--cached",
+				"--force",
+				"--quiet",
+				"--ignore-unmatch",
+				"--",
+				...onto.paths
+			], env);
+			git(repo, [
+				"add",
+				"--all",
+				"--",
+				...onto.paths
+			], env);
+		} else {
+			attempt(() => copyFileSync(resolve(repo.root, git(repo, [
+				"rev-parse",
+				"--git-path",
+				"index"
+			])), index));
+			git(repo, [
+				"add",
+				"--all",
+				":/"
+			], env);
+		}
 		return git(repo, ["write-tree"], env);
 	} finally {
 		rmSync(folder, { recursive: true });
 	}
 }
+const changedSince = (repo, commit, paths) => attempt(() => git(repo, [
+	"diff",
+	"--quiet",
+	`${commit}^{tree}`,
+	treeNow(repo),
+	"--",
+	...paths
+])) === void 0;
 const PLAYTHROUGH = {
 	GIT_AUTHOR_NAME: "Playthrough",
 	GIT_AUTHOR_EMAIL: "playthrough@localhost",
@@ -81,19 +122,65 @@ async function recordOnBefore(repo, id, number, flows) {
 	if (!before) return;
 	const later = flows.filter((name) => !before.flows.some((flow) => flow.name === name) && !before.cantStart?.includes(name));
 	if (!later.length) return;
-	const [are, they] = later.length > 1 ? ["are", "they're"] : ["is", "it's"];
-	await onBefore(repo, id, later, `${list(later.map(quote))} ${are} new, so ${they} recorded on Before too`, `Round ${number} wasn't recorded`, "Record again.");
+	const [are, they, have] = later.length > 1 ? [
+		"are",
+		"they're",
+		"have"
+	] : [
+		"is",
+		"it's",
+		"has"
+	];
+	const named = called(later);
+	await onBefore(repo, id, later, `${named} ${are} new, so ${they} recorded on Before too`, `Round ${number} wasn't recorded`, "Record again.", (why) => `${named} ${have} no Before: ${why}.`);
 }
-async function tryBeforeAgain(repo, id, flows) {
-	const [them, they] = flows.length > 1 ? ["them", "they"] : ["it", "it"];
-	await onBefore(repo, id, flows, `Before cut ${list(flows.map(quote))} short, so ${they} ${flows.length > 1 ? "are" : "is"} tried on it again, in place of what it has of ${them}`, "Before wasn't recorded again", "Run this again.");
+async function changedOnBefore(repo, review) {
+	const before = review.rounds.find((round) => round.number === 0);
+	if (!before) return [];
+	const handedOver = review.rounds.some((round) => round.number > 0 && round.finished);
+	const flows = [...before.flows.filter((flow) => !handedOver || flow.stopped).map((flow) => flow.name), ...before.cantStart ?? []];
+	const ran = await ranOnBefore(repo, review.id);
+	return flows.filter((name) => !ran[name] || hashOf(join(repo.flows(review.id), ran[name].file)) !== ran[name].hash);
 }
-async function onBefore(repo, id, flows, doing, unrecorded, again) {
+const ranOnBefore = (repo, id) => readFile(repo.ranOnBefore(id), "utf8").then(JSON.parse, () => ({}));
+async function noteRanOnBefore(repo, id, written, gone = []) {
+	const ran = {
+		...await ranOnBefore(repo, id),
+		...written
+	};
+	for (const name of gone) delete ran[name];
+	await writeFile(repo.ranOnBefore(id), JSON.stringify(ran));
+}
+async function tryBeforeAgain(repo, id, flows, again) {
+	const [has, they, them] = flows.length > 1 ? [
+		"have",
+		"they're",
+		"them"
+	] : [
+		"has",
+		"it's",
+		"it"
+	];
+	const named = called(flows);
+	await onBefore(repo, id, flows, `${named} ${has} changed since ${flows.length > 1 ? "they" : "it"} last ran on Before, so ${they} recorded on it again, in place of what it has of ${them}`, "Before wasn't recorded again", again, (why) => `Before can't record ${named} again: ${why}.`);
+}
+async function recordBeforeAgain(repo, id, command, again) {
+	const review = await repo.reviews.get(id);
+	const before = review.rounds.find((round) => round.number === 0);
+	if (!before?.commit || review.rounds.some((round) => round.number > 0 && round.finished) || !changedSince(repo, before.commit, ["playthrough"])) return false;
+	await trySetup(repo, command);
+	return onBefore(repo, id, [...before.flows.map((flow) => flow.name), ...before.cantStart ?? []], `playthrough/ has changed since Before was recorded, so Before is recorded again on it, in place of what it has`, "Before wasn't recorded again", again, (why) => `Before stays as it was recorded, on playthrough/ as it was then: ${why}.`, true);
+}
+async function onBefore(repo, id, flows, doing, unrecorded, again, cant, whole = false) {
 	const before = (await repo.reviews.get(id)).rounds.find((round) => round.number === 0);
-	const named = list(flows.map(quote));
-	if (!before.commit) return console.log(`\n${named} ${flows.length > 1 ? "have" : "has"} no Before: Before wasn't kept as a commit, so the app as it was can't be put back.`);
+	const unchanged = !!before.commit && !changedSince(repo, before.commit, [":/", ":(exclude)playthrough"]);
+	const why = !before.commit ? "Before wasn't kept as a commit, so the app as it was can't be put back" : !unchanged && !headOf(repo) ? UNBORN : void 0;
+	if (why) {
+		console.log(`\n${cant(why)}`);
+		return false;
+	}
 	const later = flows;
-	const taken = before.flows.map((flow) => flow.recording);
+	const taken = await repo.reviews.files(id, 0);
 	const run = () => runFlows(repo, id, 0, {
 		later: {
 			flows: later,
@@ -103,47 +190,61 @@ async function onBefore(repo, id, flows, doing, unrecorded, again) {
 	}).catch((error) => {
 		if (error instanceof Refused) return {
 			recorded: [],
-			failed: later.map((flow) => ({ flow }))
+			failed: later.map((flow) => ({ flow })),
+			written: {}
 		};
 		throw error;
 	});
 	let ran;
-	if (treeNow(repo) === git(repo, ["rev-parse", `${before.commit}^{tree}`])) {
+	if (unchanged) {
 		console.log(`\n${doing}, on the app as it is: nothing has changed since Before.`);
 		ran = await run();
 	} else {
 		const { url } = await repo.app();
-		const shared = await serving(url);
+		await stopApp(url);
+		const shared = await serves(url);
 		console.log(`\n${doing}. Your work is set aside with git stash meanwhile${shared ? `, and what serves ${url} serves the app as it was` : ""}.`);
 		ran = await asItWas(repo, unrecorded, before.commit, shared, async () => {
 			if (shared) await caughtUp(url);
-			return run();
+			try {
+				return await run();
+			} finally {
+				await stopApp(url);
+			}
 		});
+		if (shared) await caughtUp(url);
 	}
 	refuseIfBroken(ran.failed, unrecorded, again);
+	const commit = whole ? keptWithOursNow(repo, id, before.commit) : void 0;
+	const gone = later.filter((name) => !ran.recorded.some(({ flow }) => flow.name === name) && !ran.failed.some(({ flow }) => flow === name));
 	await repo.reviews.addToBefore(id, {
 		flows: ran.recorded.map(({ flow }) => flow),
 		cantStart: cantStart(ran.recorded, ran.failed),
-		files: ran.recorded.flatMap(({ files }) => files)
+		files: ran.recorded.flatMap(({ files }) => files),
+		...commit && { commit },
+		gone
 	});
+	await noteRanOnBefore(repo, id, ran.written, gone);
+	if (gone.length) console.log(`\n${gone.length > 3 ? `${gone.length} of them` : list(gone.map(quote))} ${gone.length > 1 ? "aren't flows" : "isn't a flow"} any more, so Before lets ${gone.length > 1 ? "them" : "it"} go.`);
 	for (const line of howFar(repo, id, ran.recorded, ran.failed, "the app as it was")) console.log(line);
+	return true;
 }
 function refuseIfBroken(failed, unrecorded, again) {
 	const broken = failed.filter((failure) => failure.broken);
 	if (broken.length) throw new Refused([
-		`${unrecorded}, because the browser stopped ${broken.length > 1 ? "these flows" : "a flow"}, not the app:`,
+		`\n${unrecorded}, because the browser stopped ${broken.length > 1 ? "these flows" : "a flow"}, not the app:`,
 		...broken.map(failedAt),
-		`Playwright says why above. ${again}`
+		again
 	]);
 }
 const cantStart = (recorded, failed) => failed.map(({ flow }) => flow).filter((flow) => !recorded.some((kept) => kept.flow.name === flow));
 function howFar(repo, id, recorded, failed, app) {
-	const lines = failed.map(({ flow, at, why }) => {
+	const lines = failed.map(({ flow, at, why, on }) => {
 		const because = why ? `, where Playwright says “${why}”` : "";
-		return !recorded.some((kept) => kept.flow.name === flow) ? `${quote(flow)} can't start on ${app}${because}, so it has no Before.` : `${quote(flow)} ${at ? `stops at ${quote(at)}${because}` : "stops after its last step"}, so its Before goes as far as that.`;
+		return !recorded.some((kept) => kept.flow.name === flow) ? `${quote(flow)} can't start on ${app}${because}, so it has no Before.` : `${quote(flow)} ${at ? `stops at ${quote(at)}${onPage(on)}${because}` : "stops after its last step"}, so its Before goes as far as that.`;
 	});
 	const where = existsSync(repo.failed(id)) ? ` ${whereItStopped(repo, id, failed)}` : "";
-	if (lines.length) lines.push(`If that's the app as it was, that's Before. If it's the flow's own mistake, fix the flow and run playthrough start ${id} again: it tries the flows Before cut short again.${where}`);
+	if (lines.length) lines.push(`If that's the app as it was, that's Before. If it's the flow's own mistake, fix the flow and run playthrough start ${id} again: it records a flow changed since on Before again.${where}`);
 	return lines;
 }
 const SIGNALS = [
@@ -169,6 +270,9 @@ async function asItWas(repo, unrecorded, commit, shared, run) {
 		process.exit(128 + constants.signals[signal]);
 	};
 	for (const signal of SIGNALS) process.on(signal, stopped);
+	const ours = join(repo.root, "playthrough");
+	const today = existsSync(ours) ? mkdtempSync(join(tmpdir(), "playthrough-")) : void 0;
+	if (today) cpSync(ours, today, { recursive: true });
 	let moved = false;
 	try {
 		try {
@@ -178,7 +282,10 @@ async function asItWas(repo, unrecorded, commit, shared, run) {
 				"--include-untracked",
 				"--message",
 				aside.stash
-			]);
+			], {
+				...process.env,
+				...PLAYTHROUGH
+			});
 			git(repo, [
 				"checkout",
 				"--quiet",
@@ -193,8 +300,19 @@ async function asItWas(repo, unrecorded, commit, shared, run) {
 				"Fix that, then try again."
 			]);
 		}
+		if (today) {
+			rmSync(ours, {
+				recursive: true,
+				force: true
+			});
+			cpSync(today, ours, { recursive: true });
+		}
 		return await run();
 	} finally {
+		if (today) rmSync(today, {
+			recursive: true,
+			force: true
+		});
 		for (const signal of SIGNALS) process.off(signal, stopped);
 		const problem = putWorkBack(repo, aside, true);
 		if (problem) throw stillAside(repo, aside, problem);
@@ -210,17 +328,34 @@ async function putBack(repo) {
 	if (!toDo) return;
 	const back = `Playthrough was stopped while your work was set aside for a flow to record on Before. It's back now, on ${aside.back}.`;
 	const url = (await repo.app().catch(() => void 0))?.url;
-	if (url && !aside.shared && await serving(url)) throw new Refused([back, `Something is still serving ${url}, most likely the app as it was, left running: stop it, then run this again.`]);
+	if (url && !aside.shared && await serves(url)) throw new Refused([back, `Something is still serving ${url}, most likely the app as it was, left running: stop it, then run this again.`]);
 	console.log(`${back}\n`);
 }
 function putWorkBack(repo, aside, force) {
 	try {
-		if (here(repo) !== aside.back) git(repo, [
-			"checkout",
-			"--quiet",
-			...force ? ["--force"] : [],
-			aside.back
-		]);
+		if (here(repo) !== aside.back) {
+			attempt(() => git(repo, [
+				"checkout",
+				"--quiet",
+				"HEAD",
+				"--",
+				"playthrough"
+			]));
+			git(repo, [
+				"clean",
+				"--force",
+				"-d",
+				"--quiet",
+				"--",
+				"playthrough"
+			]);
+			git(repo, [
+				"checkout",
+				"--quiet",
+				...force ? ["--force"] : [],
+				aside.back
+			]);
+		}
 		const stash = stashOf(repo, aside);
 		if (stash) git(repo, [
 			"stash",
@@ -242,6 +377,13 @@ function stillAside(repo, aside, problem) {
 		`Put it back with git checkout ${aside.back}${stash ? `, then git stash pop --index ${stash}` : ""}. Playthrough carries on once it's back.`
 	]);
 }
+const headOf = (repo) => attempt(() => git(repo, [
+	"rev-parse",
+	"--verify",
+	"--quiet",
+	"HEAD"
+]));
+const UNBORN = "this repo has no commits yet, and git can set your work aside to put the app as it was back only once it has one";
 const here = (repo) => attempt(() => git(repo, [
 	"symbolic-ref",
 	"--quiet",
@@ -255,7 +397,6 @@ function stashOf(repo, aside) {
 		"--format=%gd %gs"
 	]).split("\n").find((stash) => stash.endsWith(aside.stash))?.split(" ")[0];
 }
-const serving = (url) => fetch(url, { signal: AbortSignal.timeout(2e3) }).then((response) => (response.body?.cancel(), true), () => false);
 async function caughtUp(url) {
 	await new Promise((done) => setTimeout(done, 1e3));
 	await fetch(url, { signal: AbortSignal.timeout(6e4) }).then((response) => response.body?.cancel(), () => {});
@@ -391,7 +532,7 @@ async function start$1(repo, id, to, files, written) {
 	const { flows, setup } = await loadedOf(repo, id, files, written);
 	const kept = flows.get(to.flow);
 	if (!kept) throw new Refused([`${id} has no flow called ${quote(to.flow)} any more. Its flows: ${list([...flows.keys()].map(quote))}.`]);
-	const { context, page } = await pageFor(await browser(), app.url, kept.use);
+	const { context, page } = await pageFor(await browser(), app.url, kept.use, setup.use);
 	context.setDefaultTimeout(1e4);
 	context.setDefaultNavigationTimeout(0);
 	const request$2 = await request.newContext({ baseURL: app.url });
@@ -1378,21 +1519,27 @@ async function record(repo, id) {
 	const number = review.rounds.length ? roundInProgress(review) : 1;
 	const onBefore = !!review.rounds.find((round) => round.number === 0)?.commit;
 	const first = (flow) => !onBefore && !review.rounds.some((round) => round.number !== number && round.flows.some((kept) => kept.name === flow));
+	if (number === 1 && !await recordBeforeAgain(repo, id, `playthrough record ${id}`, "Record again.")) {
+		const again = await changedOnBefore(repo, review);
+		if (again.length) await tryBeforeAgain(repo, id, again, "Record again.");
+	}
 	const { recorded, failed } = await runFlows(repo, id, number, { first });
 	if (failed.length) throw new Refused([
-		`Round ${number} wasn't recorded, because ${failed.length > 1 ? "these flows" : "a flow"} failed:`,
+		`\nRound ${number} wasn't recorded, because ${failed.length > 1 ? "these flows" : "a flow"} failed:`,
 		...failed.map(failedAt),
 		`Fix ${failed.length > 1 ? "them" : "it"} and record again, which runs ${failed.length > 1 ? "them" : "it"} first. ${whereItStopped(repo, id, failed)}`
 	]);
 	await recordOnBefore(repo, id, number, recorded.map(({ flow }) => flow.name));
 	const saved = review.rounds.find((round) => round.number === number);
+	const joined = inOrderJoined(review);
+	const place = (name) => joined.includes(name) ? joined.indexOf(name) : joined.length;
 	const flows = recorded.map(({ flow }) => {
 		const line = saved?.flows.find((kept) => kept.name === flow.name)?.line;
 		return line ? {
 			...flow,
 			line
 		} : flow;
-	});
+	}).sort((a, b) => place(a.name) - place(b.name));
 	for (const { files } of recorded) for (const { name, bytes } of files) await repo.reviews.saveFile(id, number, name, bytes);
 	const written = saved?.replies ?? [];
 	const waiting = notesToAnswer(review, number).filter((note) => !written.some((reply) => reply.note === note)).map((note) => ({
@@ -1416,20 +1563,19 @@ async function record(repo, id) {
 	const unsaid = flows.filter((flow) => !flow.line && !previous?.flows.some((kept) => kept.name === flow.name));
 	const file = repo.show(repo.round(id, number));
 	const left = problemsFinishing(await repo.reviews.get(id), number);
-	console.log(`\nRecorded round ${number}: ${list(flows.map((flow) => `${quote(flow.name)} (${Math.round(flow.length)}s)`))}.`);
+	console.log(`\nRecorded round ${number}: ${flows.length > 3 ? called(flows.map((flow) => flow.name)) : list(flows.map((flow) => `${quote(flow.name)} (${Math.round(flow.length)}s)`))}.`);
 	const since = comparisons.find((comparison) => comparison.since === number - 1);
 	if (since) console.log(`\n${changed(since.changes.length, number - 1)}`);
 	if (since && !since.changes.length && replies.some((reply) => reply.on && !reply.on.app && !reply.watch)) console.log(`Nothing at rest shows an answer that moves, like an animation: if yours does, add "watch": "<the title of the step it's seen in>" to its reply in ${file}, and the note plays that step.`);
 	if (walked.length) console.log(`\n${walked.map(saidOf).join("\n")}`);
 	if (left.length) console.log(`\nStill to do, in ${file}:\n${left.map((problem) => `  ${problem}`).join("\n")}`);
-	if (since?.changes.some((change) => !saved?.accounts[change.id])) console.log(`\nSay why each change is there in “accounts”, by its id: { "line": "<why, in your words>" }, { "note": "<the note it was made for>" }, or { "notReal": "<why nothing really changed>" }.`);
+	if (number === 1 && !saved && since?.changes.length) console.log(`\nSay why each change is there in “accounts”, by its id: { "line": "<why, in your words>" }, { "note": "<the id of the note it was made for>" }, or { "notReal": "<why nothing really changed>" }.`);
 	if (unsaid.length) {
 		const [are, each] = unsaid.length > 1 ? ["are", "each"] : ["is", "it"];
-		console.log(`\n${list(unsaid.map((flow) => quote(flow.name)))} ${are} new to the reviewer. In ${file}, ${each} can have a line at its start, as “line” in its flow under “flows”: what it starts from, or the choice it shows, in a sentence.`);
+		console.log(`\n${list(unsaid.map((flow) => quote(flow.name)))} ${are} new to the person. In ${file}, ${each} can have a line at its start, as “line” in its flow under “flows”: what it starts from, or the choice it shows, in a sentence of up to 140 characters.`);
 	}
 	if (by === "Agent") console.log(`\nPlaythrough can't tell which agent you are. Write your name in ${file} as “by”, and each of your answers shows it.`);
-	console.log(left.length ? `\nThen hand it over: playthrough wait ${id}` : `\nHand it over when it's ready: playthrough wait ${id}`);
-	console.log("It waits for the person's notes, which can take hours: run it in the background, so you're told when it ends.");
+	console.log(`\n${left.length ? "Then hand it over" : "Hand it over when it's ready"}, in the background, so you're told when the person's notes come: playthrough wait ${id}`);
 }
 async function placed(repo, review, number, flows, reply, walked) {
 	const answer = {
@@ -1471,7 +1617,7 @@ async function start(repo, id, title, asked) {
 		await makeFlowsFolder(repo, id);
 		return console.log(`Started ${id}: “${title}”.
 
-Write its flows before you change anything. They show what was asked, so write them from the task, not from the code: if you can start a fresh subagent, give it the task and what the screens look like, never the code, and use the flows it writes.
+Write its flows before you change anything. They show what was asked, so write them from the task, not from the code.
 
 ${howToWriteFlows(repo, id)}
 
@@ -1480,13 +1626,14 @@ Then run playthrough start ${id} again. It records Before: each flow on the app
 	const review = await repo.reviews.get(id);
 	if (title && title !== review.title) throw new Refused([`There's already a review called “${id}”, of “${review.title}”. Give this one another name, or record that one's Before: playthrough start ${id}`]);
 	const last = review.rounds.at(-1);
-	const before = review.rounds.find((round) => round.number === 0);
-	const short = before ? [...before.flows.filter((flow) => flow.stopped).map((flow) => flow.name), ...before.cantStart ?? []] : [];
-	if (before && short.length) return tryBeforeAgain(repo, id, short);
+	review.rounds.find((round) => round.number === 0);
+	if (last?.number === 0 && await recordBeforeAgain(repo, id, `playthrough start ${id}`, "Run this again.")) return;
+	const changed = await changedOnBefore(repo, review);
+	if (changed.length) return tryBeforeAgain(repo, id, changed, "Run this again.");
 	if (last?.number === 0) throw new Refused([`Before is recorded already. Change the app, then record round 1: playthrough record ${id}`]);
 	if (last) throw new Refused([`Before is how the app was before the work, and ${id} has round ${last.number} already. Record the round being worked on: playthrough record ${id}`]);
 	const commit = keepBefore(repo, id);
-	const { recorded, failed } = await runFlows(repo, id, 0, { first: () => true });
+	const { recorded, failed, written } = await runFlows(repo, id, 0, { first: () => true });
 	refuseIfBroken(failed, "Before wasn't recorded", "Run this again.");
 	if (!recorded.length) return console.log(`\nNone of the flows can start on the app as it is, so there's no Before. If one should, fix it and run this again. Otherwise change the app, then record round 1: playthrough record ${id}`);
 	for (const { files } of recorded) for (const { name, bytes } of files) await repo.reviews.saveFile(id, 0, name, bytes);
@@ -1501,11 +1648,16 @@ Then run playthrough start ${id} again. It records Before: each flow on the app
 		...commit && { commit }
 	});
 	await repo.reviews.finish(id, 0);
-	console.log(`\nRecorded Before: ${list(flows.map((flow) => quote(flow.name)))}.`);
+	await noteRanOnBefore(repo, id, written);
+	console.log(`\nRecorded Before: ${called(flows.map((flow) => flow.name))}.`);
 	for (const line of howFar(repo, id, recorded, failed, "the app as it is")) console.log(line);
 	if (!commit) console.log(`This folder isn't in git, so Before isn't kept as a commit, and a flow added later can't be recorded on it.`);
+	const wrote = recorded.find((kept) => kept.wrote);
+	const { after } = await setupIn(repo.setup);
+	if (wrote && !after) console.log(`
+${quote(wrote.flow.name)} sends the app ${wrote.wrote}, which changes what it holds, and ${existsSync(repo.setup) ? "playthrough/setup.ts has no after, so what each flow makes stays in the app" : "there's no playthrough/setup.ts, so each flow starts on what the ones before it left, and what they make stays in the app"}: one for each flow recorded, two for a new one. Tell the person, with the step that would fix it; run playthrough alone for how setup.ts makes what each flow starts from, and gives it back.`);
 	console.log(`
-Now change the app. Keep each flow's name, and each step's while it does the same job: they're matched across rounds by name. Once the work is done, add a flow for each choice you made that the reviewer can see and didn't ask for. Then record round 1: playthrough record ${id}`);
+Now change the app. Keep each flow's name, and each step's while it does the same job: they're matched across rounds by name. Once the work is done, add a flow for each choice you made that the person can see and didn't ask for. Then record round 1: playthrough record ${id}`);
 }
 // src/noted.ts
 async function pictureNotes(repo, review, round, notes) {
@@ -1537,8 +1689,17 @@ async function whereSeen(repo, review, id, before) {
 	const seen = lastSeen(review, id, before);
 	const on = seen?.on;
 	const flow = seen && review.rounds.find((round) => round.number === seen.round)?.flows.find((flow) => flow.name === on.flow);
-	if (!seen || !on || on.at === void 0 || !flow) return void 0;
+	if (!seen || !on || !flow) return void 0;
 	const readings = await readingsOn(repo.reviews, review.id, seen.round, flow);
+	if (on.at === void 0) {
+		const end = readings.at(-1);
+		return end && {
+			round: seen.round,
+			picture: end.picture,
+			width: end.screen.width,
+			height: end.screen.height
+		};
+	}
 	const at = on.at;
 	const shown = on.element ? shownAt(readings, on.element, at) : void 0;
 	const reading = shown?.reading ?? readings.reduce((best, next) => !best || Math.abs(next.at - at) < Math.abs(best.at - at) ? next : best, void 0);
@@ -1585,8 +1746,9 @@ async function wait(repo, id) {
 					`${error.problems.length > 1 ? "Fix these" : "Fix it"} in ${repo.show(repo.round(id, last.number))}, then hand it over again: playthrough wait ${id}`
 				]);
 			}
-			console.log(`Round ${last.number} is ready for review.`);
-		}
+			console.log(`Round ${last.number} is ready for review. Tell the person it's theirs: npx playthrough open ${id} opens it.`);
+			review = await reviews.get(id);
+		} else console.log(`Round ${last.number} is handed over already.`);
 		console.log(`Waiting for notes on ${id}…`);
 	}
 	for (;;) {
@@ -1620,7 +1782,7 @@ async function wait(repo, id) {
 		}
 		if (asking.some((note) => notes.get(note)?.note.on?.app)) console.log(`\nWhat they did in the app is walked again on the new version when you record the round, and record says whether it still gets to their note. playthrough walk ${id} does that while you work.`);
 		const first = pictures.size ? "Look at what each note is on, change" : "Change";
-		console.log(`\n${first} the app, then record round ${round}: playthrough record ${id}`);
+		console.log(`\n${first} the app, then record round ${round}: playthrough record ${id}. Then answer each note in that round's round.json, under “replies”: record says where.`);
 		return console.log(`New to this review? Run playthrough alone for how Playthrough works. Its flows are in ${repo.show(repo.flows(id))}.`);
 	}
 }

package/src/playwright.config.js

@@ -1,15 +1,17 @@
+import { u as waitsFor } from "./flows-BcISV1M-.js";
 import { availableParallelism } from "node:os";
-import { fileURLToPath } from "node:url";
 import { defineConfig } from "@playwright/test";
+import { fileURLToPath } from "node:url";
 // src/playwright.config.ts
 const run = JSON.parse(process.env.PLAYTHROUGH_RUN ?? "null");
 var playwright_config_default = defineConfig({
 	testDir: run.flows,
 	testMatch: /\.[cm]?[jt]s$/,
 	outputDir: run.results ?? `${run.folder}/results`,
-	workers: Math.max(1, Math.floor(availableParallelism() / 4)),
-	reporter: [["list"], [fileURLToPath(new URL("./reporter.js", import.meta.url)), {
+	workers: run.app.oneAtATime ? 1 : Math.max(1, Math.floor(availableParallelism() / 4)),
+	reporter: [[fileURLToPath(new URL("./reporter.js", import.meta.url)), {
 		folder: run.folder,
+		flows: run.flows,
 		before: run.before,
 		taken: run.taken
 	}]],
@@ -19,15 +21,9 @@ var playwright_config_default = defineConfig({
 			width: 1280,
 			height: 800
 		},
-		actionTimeout: 1e4,
+		actionTimeout: waitsFor(run),
 		screenshot: "only-on-failure"
 	},
-	webServer: {
-		command: run.app.start,
-		url: run.app.url,
-		cwd: run.root,
-		reuseExistingServer: true
-	},
 	...run.longest?.length && { projects: [{
 		name: "new",
 		grepInvert: run.longest.map(titled)