playthrough 0.3.0 → 0.4.0

package/src/playthrough.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env -S node --disable-warning=MODULE_TYPELESS_PACKAGE_JSON
-import { A as time, C as conversation, D as roundInProgress, E as problemsFinishing, O as list, S as allNotes, T as notesToAnswer, _ as readingsOn, b as Refused, h as hashOf, k as quote, p as firstLine, w as lastSeen } from "./reporter-4C_7joIm.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-Dt7fcPLt.js";
+import { A as list, C as conversation, D as problemsFinishing, E as notesToAnswer, M as time, O as roundInProgress, S as allNotes, T as lastSeen, _ as readingsOn, b as Refused, j as quote, k as toAccountFor, p as firstLine, w as inOrderJoined } from "./reporter-DE8aueAO.js";
+import { D as setupIn, O as repo, _ as placeIn, a as failedAt, b as serves, c as isFlow, f as walkFork, g as compareWithEarlier, h as writtenNow, i as called, k as pausedAt, l as makeFlowsFolder, m as trySetup, o as flowsOf, p as whereItStopped, s as howToWriteFlows, t as ALONGSIDE, u as runFlows, v as shownAt, w as giveBackLeft, x as stopApp, y as keepRunning } from "./flows-BkG0TgHA.js";
 import { t as read } from "./read-Bg9XVTtn.js";
 import { createRequire } from "node:module";
 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 { createHash } from "node:crypto";
 import { constants, networkInterfaces, tmpdir, userInfo } from "node:os";
 import { dirname, extname, join, normalize, resolve, sep } from "node:path";
 import { chromium, request } from "@playwright/test";
@@ -21,9 +22,27 @@ if (major < 24) {
 // src/before.ts
 function keepBefore(repo, id) {
 	if (!attempt(() => git(repo, ["rev-parse", "--is-inside-work-tree"]))) return void 0;
+	const head = headOf(repo);
+	if (!head) return void 0;
 	try {
-		const head = headOf(repo);
-		return keep(repo, id, treeNow(repo), head ? [head] : []);
+		const commit = git(repo, [
+			"commit-tree",
+			"--no-gpg-sign",
+			"-p",
+			head,
+			"-m",
+			`Before, of the review ${id}: the app as it was, with what wasn't committed`,
+			treeNow(repo)
+		], {
+			...process.env,
+			...PLAYTHROUGH
+		});
+		git(repo, [
+			"update-ref",
+			`refs/playthrough/${id}/before`,
+			commit
+		]);
+		return commit;
 	} catch (error) {
 		throw new Refused([
 			"Before can't be kept as a commit, because git says:",
@@ -32,179 +51,82 @@ function keepBefore(repo, id) {
 		]);
 	}
 }
-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) {
+function treeNow(repo) {
 	const folder = mkdtempSync(join(tmpdir(), "playthrough-"));
 	try {
 		const index = join(folder, "index");
-		const env = {
+		attempt(() => copyFileSync(resolve(repo.root, git(repo, [
+			"rev-parse",
+			"--git-path",
+			"index"
+		])), index));
+		git(repo, [
+			"add",
+			"--all",
+			":/"
+		], {
 			...process.env,
 			GIT_INDEX_FILE: index
-		};
-		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);
+		});
+		return git(repo, ["write-tree"], {
+			...process.env,
+			GIT_INDEX_FILE: index
+		});
 	} 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",
 	GIT_COMMITTER_NAME: "Playthrough",
 	GIT_COMMITTER_EMAIL: "playthrough@localhost"
 };
-async function recordOnBefore(repo, id, number, flows) {
-	const before = (await repo.reviews.get(id)).rounds.find((round) => round.number === 0);
-	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, 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 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);
-}
-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 handedOver = (review, flow) => review.rounds.some((round) => round.number > 0 && round.finished && round.flows.some((kept) => kept.name === flow));
+async function recordOnBefore(repo, id, number, { recorded, written }) {
 	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 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;
+	if (!before) return;
+	const ran = await readFile(repo.ranOnBefore(id), "utf8").then(JSON.parse, () => ({}));
+	const setup = await writtenNow(repo);
+	const follows = Object.fromEntries(recorded.map(({ flow, doneOn }) => [flow.name, createHash("sha256").update(JSON.stringify([
+		written[flow.name]?.hash,
+		setup,
+		doneOn ?? {}
+	])).digest("hex")]));
+	const on = [...before.flows.map((flow) => flow.name), ...before.cantStart ?? []];
+	const flows = recorded.filter(({ flow }) => !on.includes(flow.name) || !handedOver(review, flow.name) && ran[flow.name] !== follows[flow.name]);
+	const gone = on.filter((name) => !handedOver(review, name) && !recorded.some(({ flow }) => flow.name === name));
+	if (!flows.length && !gone.length) return;
+	const names = flows.map(({ flow }) => flow.name);
+	const unrecorded = `Round ${number} wasn't recorded`;
+	const why = !before.commit ? "Before wasn't kept as a commit, so the app as it was can't be put back" : !headOf(repo) ? UNBORN : void 0;
+	if (why) return void (names.length && console.log(`\n${called(names)} ${names.length > 1 ? "have" : "has"} no Before: ${why}.`));
 	const taken = await repo.reviews.files(id, 0);
-	const run = () => runFlows(repo, id, 0, {
-		later: {
-			flows: later,
-			taken
-		},
-		first: () => true
-	}).catch((error) => {
+	const doneInRound = Object.fromEntries(flows.map(({ flow, doneOn }) => [flow.name, doneOn ?? {}]));
+	const run = () => runFlows(repo, id, 0, { before: {
+		flows: names,
+		taken,
+		doneInRound
+	} }).catch((error) => {
 		if (error instanceof Refused) return {
 			recorded: [],
-			failed: later.map((flow) => ({ flow })),
+			failed: names.map((flow) => ({ flow })),
 			written: {}
 		};
 		throw error;
 	});
-	let ran;
-	if (unchanged) {
-		console.log(`\n${doing}, on the app as it is: nothing has changed since Before.`);
-		ran = await run();
-	} else {
+	let kept = {
+		recorded: [],
+		failed: [],
+		written: {}
+	};
+	if (names.length) {
 		const { url } = await repo.app();
 		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 () => {
+		console.log(`\nYour work is set aside with git stash while ${names.length > 1 ? "they record" : "it records"} on Before${shared ? `, and what serves ${url} serves the app as it was` : ""}.`);
+		kept = await asItWas(repo, unrecorded, before.commit, shared, async () => {
 			if (shared) await caughtUp(url);
 			try {
 				return await run();
@@ -213,21 +135,17 @@ async function onBefore(repo, id, flows, doing, unrecorded, again, cant, whole =
 			}
 		});
 		if (shared) await caughtUp(url);
+		refuseIfBroken(kept.failed, unrecorded, "Record again.");
 	}
-	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),
-		...commit && { commit },
+		flows: kept.recorded.map(({ flow }) => flow),
+		cantStart: cantStart(kept.recorded, kept.failed),
+		files: kept.recorded.flatMap(({ files }) => files),
 		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;
+	for (const name of names) ran[name] = follows[name];
+	for (const name of gone) delete ran[name];
+	await writeFile(repo.ranOnBefore(id), JSON.stringify(ran));
 }
 function refuseIfBroken(failed, unrecorded, again) {
 	const broken = failed.filter((failure) => failure.broken);
@@ -238,15 +156,6 @@ function refuseIfBroken(failed, unrecorded, 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 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.`;
-	});
-	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 records a flow changed since on Before again.${where}`);
-	return lines;
-}
 const SIGNALS = [
 	"SIGINT",
 	"SIGTERM",
@@ -1517,27 +1426,24 @@ async function record(repo, id) {
 	const review = await repo.reviews.get(id);
 	if (review.accepted) throw new Refused(["This review is accepted, so nothing more can be recorded."]);
 	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 });
+	const ran = await runFlows(repo, id, number, { first: (flow) => !handedOver(review, flow) });
+	const { recorded, failed } = ran;
 	if (failed.length) throw new Refused([
 		`\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));
+	await recordOnBefore(repo, id, number, ran);
 	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) => ({
@@ -1563,11 +1469,30 @@ async function record(repo, id) {
 	const left = problemsFinishing(await repo.reviews.get(id), number);
 	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)}`);
+	const named = toAccountFor(since);
+	if (since) console.log(`\n${changed(named.length, number - 1)}`);
+	const pictured = since?.changes.filter((change) => change.pictureOnly) ?? [];
+	if (pictured.length) {
+		const [parts, look, them, need] = pictured.length > 1 ? [
+			`${pictured.length} parts of the page`,
+			"look",
+			"them",
+			"they need"
+		] : [
+			"One part of the page",
+			"looks",
+			"it",
+			"it needs"
+		];
+		console.log(`${parts} only ${look} different in the pictures, with nothing read there changed${pictured.length > 3 ? "" : `: ${list(pictured.map((change) => quote(change.words)))}`}. The person sees ${them} on the recording, and ${need} nothing from you, unless it's what you changed for a note: then say so in “accounts”, and it shows in your answer.`);
+	}
 	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 (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 note it was made for>" }, or { "notReal": "<why nothing really changed>" }.`);
+	if (number === 1 && !saved && named.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>" }.`);
+	const wrote = number === 1 && !saved && recorded.find((kept) => kept.wrote);
+	if (wrote && !(await setupIn(repo.setup)).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, three 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.`);
 	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 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.`);
@@ -1619,42 +1544,30 @@ Write its flows before you change anything. They show what was asked, so write t
 
 ${howToWriteFlows(repo, id)}
 
-Then run playthrough start ${id} again. It records Before: each flow on the app as it is, as far as the app can take it. If the app is new, there's no Before: go straight to the work.`);
+Then run playthrough start ${id} again. It tries the app's setup, and keeps the app as it is as Before, to record each flow on with round 1, so the person can compare. If the app is new, there's no Before: go straight to the work.`);
 	}
 	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}`]);
+	if (title && title !== review.title) throw new Refused([`There's already a review called “${id}”, of “${review.title}”. Give this one another name, or carry that one on: playthrough start ${id}`]);
 	const last = review.rounds.at(-1);
-	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?.number === 0) throw new Refused([`Before is kept 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}`]);
+	await flowsOf(repo, id);
+	await trySetup(repo, `playthrough start ${id}`);
 	const commit = keepBefore(repo, id);
-	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);
-	const flows = recorded.map(({ flow }) => flow);
-	await repo.reviews.saveRound(id, {
-		number: 0,
-		by: agent(),
-		flows,
-		replies: [],
-		accounts: {},
-		cantStart: cantStart(recorded, failed),
-		...commit && { commit }
-	});
-	await repo.reviews.finish(id, 0);
-	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.`);
+	if (commit) {
+		await repo.reviews.saveRound(id, {
+			number: 0,
+			by: agent(),
+			flows: [],
+			replies: [],
+			accounts: {},
+			commit
+		});
+		await repo.reviews.finish(id, 0);
+	}
 	console.log(`
+${commit ? "Kept Before: the app as it is now. Each flow is recorded on it with round 1, as far as the app as it was takes it, for the person to compare with." : "This folder isn't in git, or has no commits yet, so there's no Before: the app as it is can't be put back once you've changed it."}
+
 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

package/src/playwright.config.js

@@ -1,4 +1,4 @@
-import { u as waitsFor } from "./flows-Dt7fcPLt.js";
+import { d as waitsFor } from "./flows-BkG0TgHA.js";
 import { availableParallelism } from "node:os";
 import { defineConfig } from "@playwright/test";
 import { fileURLToPath } from "node:url";

package/src/{reporter-4C_7joIm.js → reporter-DE8aueAO.js}

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { z } from "zod";
-import { join, relative } from "node:path";
 import { createHash } from "node:crypto";
+import { join, relative } from "node:path";
 // ../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 });
@@ -68,14 +68,15 @@ const Flow = z.strictObject({
 	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"),
+	stopped: text("needs the step it stopped at").optional().describe("On Before, the step the flow couldn't take there, or that the app as it was had something else for: it's kept as far as that"),
 	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")
+	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"),
+	pictureOnly: z.literal(true).optional().describe("Seen only in the pictures, with nothing read there changed: shown to the person, who can see what it is, and not put to the agent, who can't see more of it than Playthrough did")
 });
 const Comparison = z.strictObject({
 	round: z.number({ error: "needs its round" }).int().min(1, { error: "needs its round, after Before" }),
@@ -84,7 +85,7 @@ const Comparison = z.strictObject({
 });
 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({ note: text("needs the id of 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({
@@ -153,6 +154,9 @@ function roundInProgress(review) {
 	if (!last) return 0;
 	return last.finished ? last.number + 1 : last.number;
 }
+function inOrderJoined(review) {
+	return [...new Set(review.rounds.flatMap((kept) => [...kept.flows.map((flow) => flow.name), ...kept.cantStart ?? []]))];
+}
 function allNotes(review) {
 	const notes = /* @__PURE__ */ new Map();
 	for (const send of review.sends) for (const note of send.notes) notes.set(note.id, {
@@ -315,6 +319,7 @@ function problemsWithComparison(review, comparison) {
 	}
 	return problems;
 }
+const toAccountFor = (comparison) => (comparison?.changes ?? []).filter((change) => !change.pictureOnly);
 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);
@@ -322,7 +327,7 @@ function problemsFinishing(review, number) {
 	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.`];
+	if (number > 0 && !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)) {
@@ -335,7 +340,7 @@ function problemsFinishing(review, number) {
 	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 change of toAccountFor(comparisons.find((comparison) => comparison.since === number - 1))) if (!round.accounts[change.id]) problems.push(`${at}: say why ${change.id} is there (${change.words}${where(change)}): its line, the id of 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.`);
@@ -588,10 +593,7 @@ var Reviews = class {
 			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 }
-			});
+			await this.#writeJson(`${id}/rounds/0/round.json`, withInBefore(before, added.flows, added.cantStart, added.gone));
 		});
 	}
 	async saveComparison(id, comparison) {
@@ -730,7 +732,7 @@ const PERSON = "playthrough person";
 const HANDS = "playthrough hands";
 const ACTIONS = "playthrough actions";
 const WROTE = "playthrough wrote";
-const UNMET = "playthrough unmet";
+const DONE_ON = "playthrough done on";
 const HOLD = 1500;
 const readingsOf = (flow) => `readings/${flow.recording}`;
 async function readingsOn(reviews, review, round, flow) {
@@ -786,14 +788,14 @@ var Flows = class {
 		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 doneOn = result.attachments.find((attachment) => attachment.name === DONE_ON)?.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;
+			if (doneOn) made.doneOn = JSON.parse(doneOn);
 			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;
@@ -802,7 +804,7 @@ var Flows = class {
 				...where,
 				recorded
 			});
-			return went(`to its end, ${Math.round(recorded.flow.length)}s${yet}`);
+			return went(`to its end, ${Math.round(recorded.flow.length)}s`);
 		}
 		const stop = steps.at(-1);
 		const kept = stop?.error ? steps.slice(0, -1) : steps;
@@ -830,7 +832,7 @@ var Flows = class {
 			failed,
 			recorded
 		});
-		went(`${stop.error ? `stops at ${quote(stop.title)}` : "stops after its last step"}${yet}`);
+		went(stop.error ? `stops at ${quote(stop.title)}` : "stops after its last step");
 	}
 	onError(error) {
 		console.log(`\n${error.message ?? error.value}`);
@@ -916,4 +918,4 @@ var Flows = class {
 	}
 };
 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 };
+export { list as A, conversation as C, problemsFinishing as D, notesToAnswer as E, time as M, roundInProgress as O, allNotes as S, lastSeen as T, readingsOn as _, GLIMPSES as a, Refused as b, PERSON as c, RECORDING as d, WROTE as f, readingsOf as g, hashOf as h, Flows as i, quote as j, toAccountFor as k, PICTURE as l, glimpsesOf as m, ASSETS as n, HANDS as o, firstLine as p, DONE_ON as r, HOLD as s, ACTIONS as t, READINGS as u, seconds as v, inOrderJoined as w, Reviews as x, keepAssets as y };

package/src/reporter.js

@@ -1 +1 @@
-export { t as ACTIONS, n as ASSETS, i as GLIMPSES, a as HANDS, o as HOLD, s as PERSON, c as PICTURE, l as READINGS, u as RECORDING, d as UNMET, f as WROTE, r as default, p as firstLine, m as glimpsesOf, h as hashOf, g as readingsOf, _ as readingsOn, v as seconds } from "./reporter-4C_7joIm.js";
+export { t as ACTIONS, n as ASSETS, r as DONE_ON, a as GLIMPSES, o as HANDS, s as HOLD, c as PERSON, l as PICTURE, u as READINGS, d as RECORDING, f as WROTE, i as default, p as firstLine, m as glimpsesOf, h as hashOf, g as readingsOf, _ as readingsOn, v as seconds } from "./reporter-DE8aueAO.js";