playthrough 0.5.0 → 0.6.0

package/INSTRUCTIONS.md

@@ -6,7 +6,7 @@ to its end; each command then says what's next.
   playthrough start <review>             once its flows are written, try the setup and keep Before: the app as it is
   playthrough record <review>            record the round being worked on, every flow, the way a person would use it
   playthrough wait <review>              hand the round over, then wait for the notes to answer
-  playthrough walk <review>              walk the person's steps in the app again, on the app as it is now
+  playthrough forks <review>             run each fork of a note made in the app, on the app as it is now
   playthrough open [<review>]            open the viewer on this machine
 
 THE LOOP
@@ -22,17 +22,22 @@ THE LOOP
    does as far as the app as it was can, then compares the round with every round before it. In the round's round.json,
    say why each change since the round before is there, under "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>" }. What only the
-   pictures show is the person's to look at, and asks nothing of you, unless you made it for a note: then say so.
+   pictures show is the person's to look at, and asks nothing of you, unless you made it for a note: then say so. The
+   person sees what changed, marked where it is: a line says only why, in a short sentence.
 5. playthrough wait <review> hands the round over and waits for the notes, which can take hours: run it in the
    background, so you're told when it ends. Each note comes with a picture of what it's on, or what the person did in
    the app. Change the app, record the next round, and answer each note in its round.json, under "replies", in its
    "words": its "on" is where Playthrough found the note's thing on this round, so leave it. Where the answer moves,
-   like an animation, add "watch": "<the title of the step it's seen in>". For a note made in the app, record walks the
-   person's steps again and puts your answer where they lead: answer it in words, not with a new flow, and check your
-   fix with playthrough walk <review>. Where their steps stop short, fix that, or say why they changed.
+   like an animation, add "watch": "<the title of the step it's seen in>". A note made in the app comes with what the
+   person did there: write that as a fork of the flow they took over (FORKS, below), and record puts your answer on it.
 
 The person can only judge what the flows show, so keep them true to how a person uses the app.
 
+A bug you can't make happen is still a round to hand over: record the flow that does what the report says, give it a
+"line" in round.json saying you couldn't make it happen and how you tried, and hand it over. The person can take the
+flow over where it goes wrong and show you: what they do there comes back as a note made in the app, and its fork, run
+every round, shows you the bug and them your fix.
+
 THE APP
 
 The first time, add playthrough to the app's devDependencies with the app's own package manager, and run
@@ -55,7 +60,8 @@ another at its address, takes the address it always has, or a copy on a port of
 
 Flows run several at once. Where a page shows what every run made, as a blog's index lists every post, add
 "oneAtATime": true. Recording on Before sets your work aside with git stash for a minute, puts the app as it was in its
-place, with playthrough/ as it is now, and puts your work back after, even when Playthrough is stopped.
+place, with playthrough/ as it is now, and puts your work back after, even when Playthrough is stopped; anything saved
+meanwhile is kept in a stash of its own.
 
 FLOWS
 
@@ -79,11 +85,34 @@ the page once it rests after each step. A dialog the browser shows is recorded,
 first: page.once("dialog", (dialog) => dialog.accept()). A flow that fails stops the round: record names it and the
 step, and keeps the page it failed on in .playthrough/<review>/failed/.
 
+Steps go where a person goes, by what the app had before your work too, never to what you changed: the app as it was
+doesn't have it, so Before stops short there and your change reads as new steps. Playthrough finds what changed, and
+shows each change when the recording first has it on the screen. A page people read, like a landing page or docs, is a
+flow of reading it, top to bottom: a step for each screen, scrolled with page.mouse.wheel(0, 600), which Playthrough scrolls as a person does, as
+many as the longer page needs.
+
 While the person watches, Playthrough runs the flow again in the background, so taking it over is quick. If its steps do
 something outside the app that mustn't happen again, like sending an email, say so, and it runs only when taken over:
 
   test("Invite Sam", { annotation: { type: "reaches outside", description: "sends Sam an email" } }, async ({ page }) => {
 
+FORKS
+
+Where the person took a flow over in the app and made a note there, what they did is yours to write, as a fork of that
+flow, in its file, after it: steps as a flow's, by role and label, for the notes it shows:
+
+  test.fork("Remind Alder Dental", { notes: ["isikhse8"] }, async ({ page }) => {
+    await test.step("Open the reminder", async () => {
+      await page.getByRole("row", { name: /Alder Dental/ }).click();
+      await page.getByRole("button", { name: "Write a reminder" }).click();
+    });
+  });
+
+Record runs the flow to where they took it over, then the fork, and puts your answer on what the note is on, where the
+fork first shows it. It's run every round until its notes are settled, and the person watches it as a fork off the flow,
+not a flow of its own: keep it doing what they did, on the app as it is now. playthrough forks <review> runs it while you
+work. A round whose note has no fork, or whose fork fails, isn't recorded.
+
 WHAT EVERY FLOW STARTS FROM
 
 A flow has to start from the same place every round, or the comparison finds changes nobody made. Playthrough starts

package/README.md

@@ -4,6 +4,8 @@ The agent says it's done. You decide if it's good.
 
 Playthrough records your coding agent's change the way a person would use it, before and after, so you can watch it instead of setting it up by hand. Point at what's wrong, right on the recording, and the next round answers it there. Take over any moment and carry on in the real app. It runs on your machine, with any coding agent that has a shell.
 
+Many agents, one of you: each change arrives already recorded, and one page shows which ones need you. Any flow downloads as a video, for a pull request or a teammate. Keep your code review: it reads the code; Playthrough shows what the change does.
+
 To see a review before you install anything, play the one at [playthrough.sh](https://playthrough.sh).
 
 <a href="https://playthrough.sh"><img src="https://raw.githubusercontent.com/itmostlyworks/playthrough/main/docs/viewer-light.png" alt="The viewer: the agent's recording of Send a reminder, paused on your note and the agent's answer, asking whether it fixes it, with Note, Compare and Take over on the bar"></a>
@@ -20,7 +22,7 @@ The agent does the rest. The first time, it adds Playthrough to your app and wri
 npx playthrough open
 ```
 
-Reviews stay in `.playthrough/` in your app's repo, recordings and all; nothing is uploaded. Playthrough needs Node 24 or later.
+Reviews stay in `.playthrough/` in your app's repo, recordings and all; nothing is uploaded. Playthrough needs Node 22.18 or later.
 
 You can teach your agent Playthrough once, so “Show me this change” is enough from then on:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playthrough",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Review what your coding agent built in your web app by watching recordings of it.",
   "keywords": [
     "coding-agent",
@@ -25,7 +25,7 @@
     "directory": "packages/cli"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=22.18"
   },
   "bin": {
     "playthrough": "src/playthrough.js"

package/src/{flows-DDB6AdQ-.js → flows-CbrwgoHB.js}

@@ -1,11 +1,11 @@
-import { A as quote, b as Reviews, h as readingsOf, k as list, m as glimpsesOf, p as firstLine, y as Refused } from "./reporter-Dr7dWwSf.js";
+import { A as quote, b as Reviews, h as readingsOf, k as list, m as glimpsesOf, p as firstLine, y as Refused } from "./reporter-DlS7qehW.js";
 import * as modules from "node:module";
 import { createRequire } from "node:module";
-import { existsSync, watch } from "node:fs";
+import { existsSync, readFileSync, watch, writeFileSync } from "node:fs";
 import { execFileSync, spawn } from "node:child_process";
 import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
-import { constants, tmpdir } from "node:os";
+import { constants, tmpdir, uptime } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { createServer } from "node:net";
 import { chromium, request } from "@playwright/test";
@@ -69,6 +69,30 @@ function pausedAt(flow, at) {
 		actions: 1
 	};
 }
+// src/command.ts
+const thisCommand = () => ({
+	by: process.pid,
+	boot: boot()
+});
+const stillAt = (command) => sameBoot(command.boot) && running(command.by);
+function boot() {
+	try {
+		return readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+	} catch {
+		return Date.now() / 1e3 - uptime();
+	}
+}
+function sameBoot(then, now = boot()) {
+	if (typeof then === "number" && typeof now === "number") return Math.abs(then - now) < 300;
+	return then === void 0 || then === now;
+}
+function running(pid) {
+	try {
+		return process.kill(pid, 0);
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
 // ../review/src/folder.ts
 const LOOK_EVERY = 2e3;
 function folder(root) {
@@ -123,6 +147,7 @@ function repo(root = home(process.cwd())) {
 		round: (review, round) => join(reviews, review, "rounds", String(round), "round.json"),
 		ranOnBefore: (review) => join(reviews, review, "ran-on-before.json"),
 		setAside: join(reviews, "set-aside.json"),
+		turn: join(reviews, "turn.json"),
 		appFile,
 		setup: join(root, "playthrough", "setup.ts"),
 		borrowed: join(reviews, "borrowed"),
@@ -214,7 +239,9 @@ async function setupIn(file, written) {
 	if (!existsSync(file)) return {};
 	const href = pathToFileURL(file).href;
 	asModule(href);
-	const module = await import(`${href}${written ? `?${written}` : ""}`);
+	const module = await import(`${href}${written ? `?${written}` : ""}`).catch((error) => {
+		throw twoPlaywrights(error, file) ?? error;
+	});
 	const inner = typeof module.default === "object" ? module.default : void 0;
 	const use = module.use ?? inner?.use;
 	const ours = Object.keys(use ?? {}).filter((option) => OURS.includes(option));
@@ -227,6 +254,16 @@ async function setupIn(file, written) {
 		...use && { use }
 	};
 }
+function twoPlaywrights(error, file) {
+	if (!/Requiring @playwright\/test second time/.test(String(error?.message))) return;
+	const version = (from) => {
+		try {
+			return modules.createRequire(from)("@playwright/test/package.json").version;
+		} catch {}
+	};
+	const theirs = version(file);
+	return new Refused([`playthrough/setup.ts loads the app's own Playwright${theirs ? ` (${theirs})` : ""} beside Playthrough's (${version(import.meta.url)}), and Playwright can't run twice at once.`, `Import only types from @playwright/test there (import type { Page } from "@playwright/test"), and expect, if it needs it, from playthrough/test. Then run this again.`]);
+}
 const setups = /* @__PURE__ */ new Set();
 function asModule(href) {
 	if (!setups.size) modules.registerHooks({ load: (url, context, next) => next(url, setups.has(url.split("?")[0]) ? {
@@ -324,7 +361,7 @@ function alive(pid) {
 // src/app.ts
 const started = /* @__PURE__ */ new Map();
 let ending = false;
-async function keepRunning(app, root) {
+async function keepRunning(app, root, { ready = false } = {}) {
 	if (!ending) {
 		ending = true;
 		const { setup, borrowed } = repo(root);
@@ -337,6 +374,7 @@ async function keepRunning(app, root) {
 		]) process.once(signal, end);
 		process.once("exit", () => [...started.keys()].forEach(stop));
 	}
+	await takeTurns(root, ready);
 	const ours = started.get(app.url);
 	if (ours && ours.root !== root) await stopApp(app.url);
 	if (await serves(app.url)) {
@@ -359,6 +397,12 @@ async function keepRunning(app, root) {
 		app: running,
 		root
 	});
+	if (ready) writeFileSync(repo(root).turn, JSON.stringify({
+		...thisCommand(),
+		ready,
+		app: running.pid,
+		url: app.url
+	}));
 	const said = [];
 	for (const output of [running.stdout, running.stderr]) {
 		output.on("data", (chunk) => {
@@ -387,6 +431,29 @@ async function keepRunning(app, root) {
 		"Check that playthrough/app.json starts it there."
 	]);
 }
+async function takeTurns(root, ready) {
+	const here = repo(root);
+	let turn;
+	try {
+		turn = JSON.parse(readFileSync(here.turn, "utf8"));
+	} catch {}
+	const theirs = turn && turn.by !== process.pid && stillAt(turn) ? turn : void 0;
+	if (ready) {
+		if (theirs && !theirs.ready) throw new Refused([`Another playthrough command (process ${theirs.by}) runs the app just now, until it's done, in a minute or so. Try again then.`]);
+		return;
+	}
+	await here.keepOutOfGit();
+	writeFileSync(here.turn, JSON.stringify({
+		...thisCommand(),
+		ready
+	}));
+	if (!theirs?.ready) return;
+	try {
+		process.kill(-theirs.app);
+	} catch {}
+	const began = Date.now();
+	while (Date.now() - began < 1e4 && await serves(theirs.url)) await new Promise((resolve) => setTimeout(resolve, 250));
+}
 async function stopApp(url) {
 	if (!stop(url)) return;
 	const began = Date.now();
@@ -483,6 +550,17 @@ function rewordedWords(a, b) {
 	};
 	return `“${part(a.words)}” now says “${part(b.words)}”`;
 }
+function rewordedPart(a, b) {
+	const letter = /[\p{L}\p{N}’']/u;
+	let start = 0;
+	while (start < a.length && start < b.length && a[start] === b[start]) start++;
+	let end = 0;
+	while (end < a.length - start && end < b.length - start && a.at(-1 - end) === b.at(-1 - end)) end++;
+	let to = b.length - end;
+	while (start > 0 && letter.test(b[start - 1]) && letter.test(b[start] ?? "")) start--;
+	while (to < b.length && to > 0 && letter.test(b[to - 1]) && letter.test(b[to])) to++;
+	return b.slice(start, to).trim() || void 0;
+}
 function lookWords(a, b) {
 	const parts = [];
 	if (a.look.background !== b.look.background) parts.push("background");
@@ -599,7 +677,7 @@ function differences(then, now) {
 			});
 			continue;
 		}
-		a = b.role !== "text" ? take((a) => a.role === b.role && (a.name === b.name || samePlace(a, b) || mostlyWhereItWas(a, b) || holdsTheSameWords(a, b) || CONTROL.test(b.role) && (!!bare(b.name) && bare(a.name) === bare(b.name) || overlap(a, b) > .5))) : take((a) => a.role === "text" && samePlace(a, b)) ?? (holderOf(now, b) && goneWords.get(holderKey(now, b)) === newWords.get(holderKey(now, b)) ? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b)) : void 0) ?? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b) && !!bare(b.words) && bare(a.words) === bare(b.words));
+		a = b.role !== "text" ? take((a) => a.role === b.role && (a.name === b.name || samePlace(a, b) || mostlyWhereItWas(a, b) || holdsTheSameWords(a, b) || CONTROL.test(b.role) && (!!bare(b.name) && bare(a.name) === bare(b.name) || overlap(a, b) > .5))) : take((a) => a.role === "text" && samePlace(a, b)) ?? (holderOf(now, b) && goneWords.get(holderKey(now, b)) === newWords.get(holderKey(now, b)) ? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b)) : void 0) ?? take((a) => a.role === "text" && holderKey(then, a) === holderKey(now, b) && !!bare(b.words) && bare(a.words) === bare(b.words)) ?? take((a) => a.role === "text" && kept$1(a.words, b.words));
 		if (!a) {
 			found.push({
 				what: "new",
@@ -759,6 +837,14 @@ function gained(reading, control, was) {
 }
 const CONTROL = /^(button|link|textbox|searchbox|combobox|checkbox|radio|switch|slider|tab|menuitem|option)$/;
 const holdsControls = (reading, thing) => reading.things.some((inside) => parentOf(reading, inside) === thing && CONTROL.test(inside.role));
+function kept$1(a, b) {
+	if (a.length < 24 || a === b) return false;
+	let start = 0;
+	while (start < a.length && start < b.length && a[start] === b[start]) start++;
+	let end = 0;
+	while (end < a.length - start && end < b.length - start && a.at(-1 - end) === b.at(-1 - end)) end++;
+	return (start + end) / a.length >= 2 / 3;
+}
 const mostlyWhereItWas = (a, b) => HOLDS.test(b.role) && overlap(a, b) > .5;
 const holdsTheSameWords = (a, b) => /^(box|menu)$/.test(b.role) && !!a.wordsInside && bag(a) === bag(b);
 const bag = (thing) => (thing.wordsInside ?? "").split(" ").sort().join(" ");
@@ -854,6 +940,26 @@ const elementOf$1 = (thing, name) => ({
 	name: thing.name || name,
 	...thing.node !== void 0 && { node: thing.node }
 });
+function sameWords(one, other) {
+	const [few, many] = [wordsOf(one), wordsOf(other)].sort((a, b) => a.length - b.length);
+	return !few.length || few.filter((word) => many.includes(word)).length * 2 >= few.length;
+}
+const wordsOf = (name) => name.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
+function firstShown(element, seen) {
+	const noted = wordsOf(element.name);
+	if (!noted.length) return void 0;
+	const closeness = (thing) => {
+		const words = wordsOf(thing.name);
+		return words.filter((word) => noted.includes(word)).length / Math.max(words.length, noted.length);
+	};
+	for (const glimpse of seen.toSorted((a, b) => a.at - b.at)) {
+		const thing = glimpse.things.filter((thing) => thing.role === element.role && sameWords(thing.name, element.name)).toSorted((a, b) => closeness(b) - closeness(a))[0];
+		if (thing) return {
+			at: glimpse.at,
+			element: elementOf$1(thing, element.name)
+		};
+	}
+}
 // src/changes.ts
 const TABLES = /^(table|grid|treegrid|listbox)$/;
 const REFLOWS = /^(dialog|alertdialog|status|alert|menu|box)$/;
@@ -877,7 +983,7 @@ function changesAt(then, now, unsteady = /* @__PURE__ */ new Set(), shown = {
 	const told = [
 		...items.reordered,
 		...reordered,
-		...swappedOrMoved(moment, loose),
+		...swappedOrMoved(moment, madeRoom(loose, others, caused, along)),
 		...causesOfShifts(moment, shifts, widened, others, caused, along)
 	];
 	for (const difference of others) if (!caused.has(difference)) told.push(tell(moment, difference, along.get(difference)));
@@ -1095,6 +1201,20 @@ function layoutShifts(moves, carried) {
 		loose: all.filter((shift) => counted(shift.moves) < MANY).flatMap((shift) => shift.moves)
 	};
 }
+function madeRoom(loose, others, caused, along) {
+	const candidates = others.filter((difference) => !caused.has(difference));
+	return loose.filter((move) => {
+		const by = movedBy(move);
+		if (!near(by.x, 0) || loose.some((other) => Math.sign(movedBy(other).y) === -Math.sign(by.y))) return true;
+		const cause = causeOf(spanOf([move.now]), {
+			vertical: true,
+			by: by.y,
+			moving: true
+		}, candidates);
+		if (cause) addAlong(along, cause, "pushed", [move.now], wayOf(0, by.y));
+		return !cause;
+	});
+}
 function swappedOrMoved(moment, loose) {
 	const told = [];
 	for (const [holder, moves] of groupBy(loose, (move) => holderOf(moment.now, move.now))) {
@@ -1294,6 +1414,7 @@ function tell(moment, difference, along = {}) {
 			thing: difference.now,
 			in: now,
 			words: rewordedWords(difference.then, difference.now),
+			reworded: rewordedPart(difference.then.words, difference.now.words),
 			...along
 		};
 		case "looks different": {
@@ -1353,7 +1474,11 @@ function said(told, moment, unsteady) {
 				words: alikeWords(alike),
 				...placeOf(alike[0], now),
 				...alikeOf(alike, now),
-				pieces: alike.flatMap(piecesOf)
+				pieces: alike.flatMap(piecesOf),
+				...alike[0].reworded && { reworded: alike[0].reworded },
+				...alike[0].in !== now && { gone: true },
+				...offScreen(alike),
+				top: topOf(alike[0], now)
 			});
 			continue;
 		}
@@ -1369,11 +1494,15 @@ function said(told, moment, unsteady) {
 			id: id(changed),
 			words: sentence(words),
 			...placeOf(changed, now),
-			pieces: all.flat().flatMap(piecesOf)
+			pieces: all.flat().flatMap(piecesOf),
+			...offScreen(all.flat()),
+			top: topOf(changed, now)
 		});
 	}
 	return found;
 }
+const topOf = (told, now) => told.in === now ? told.thing.box.y / now.screen.height : 2;
+const offScreen = (told) => told.some((one) => onScreen(one.thing.box, one.in.screen)) ? {} : { offScreen: true };
 function identityOf({ in: reading, thing, what }, moment) {
 	const item = thing.item === void 0 ? void 0 : reading.items?.[thing.item];
 	if (!item) return identity(reading, thing);
@@ -1459,6 +1588,7 @@ function asItems(told, moment, id) {
 			...whole,
 			what: "reworded",
 			words: reworded,
+			reworded: rewordedPart(before.words, item.words),
 			pieces: words.flatMap((one) => one.pieces ?? [id(one)]),
 			key: `${item.role} of ${listOf(now, item)}: ${shapeOf(before.words, item.words)}`
 		}, ...all.filter((one) => one.thing.role !== "text"));
@@ -1624,7 +1754,8 @@ async function picturesAt(page, then, now, pictures) {
 			id,
 			words: sentence(words),
 			...box && { box },
-			pieces: [here ? `${HERE}${id}` : id]
+			pieces: [here ? `${HERE}${id}` : id],
+			top: patch.y / now.screen.height
 		};
 	});
 }
@@ -1875,7 +2006,7 @@ function unsteadyIn(flows) {
 async function comparing(page, earlier, round, unsteady = () => /* @__PURE__ */ new Set()) {
 	const changes = /* @__PURE__ */ new Map();
 	const pieces = /* @__PURE__ */ new Map();
-	const see = ({ id, words, place, of = [id], pictureOnly }) => {
+	const see = ({ id, words, place, of = [id], reworded, gone, pictureOnly }) => {
 		if (unsteady(place.flow).has(id)) return;
 		const change = changes.get(id);
 		for (const piece of of) (pieces.get(id) ?? pieces.set(id, /* @__PURE__ */ new Set()).get(id)).add(piece);
@@ -1883,6 +2014,8 @@ async function comparing(page, earlier, round, unsteady = () => /* @__PURE__ */
 			id,
 			words,
 			seen: [place],
+			...reworded && { reworded },
+			...gone && { gone },
 			...pictureOnly && { pictureOnly }
 		});
 		else {
@@ -1927,7 +2060,7 @@ async function compareFlow(page, earlier, before, round, flow, unsteady) {
 			now: around(glimpsed.now, flow, reading.step)
 		};
 		const pictured = await picturesAt(page, was, reading, pictures);
-		for (const found of [...changesAt(was, reading, unsteady, shown), ...pictured]) {
+		for (const found of [...changesAt(was, reading, unsteady, shown), ...pictured].sort((a, b) => (a.top ?? 0) - (b.top ?? 0))) {
 			const on = found.element ? {
 				element: found.element,
 				...found.alike && { alike: found.alike }
@@ -1941,11 +2074,14 @@ async function compareFlow(page, earlier, before, round, flow, unsteady) {
 					...on
 				},
 				of: found.pieces,
-				...pictured.includes(found) && { pictureOnly: true }
+				...found.reworded && { reworded: found.reworded },
+				...found.gone && { gone: true },
+				...pictured.includes(found) && { pictureOnly: true },
+				...found.offScreen && { offScreen: true }
 			});
 		}
 	}
-	return sightings.sort((a, b) => (a.place.at ?? 0) - (b.place.at ?? 0));
+	return sightings.sort((a, b) => Number(!!a.offScreen) - Number(!!b.offScreen) || (a.place.at ?? 0) - (b.place.at ?? 0));
 }
 function around(glimpses, flow, step) {
 	const next = flow.steps[flow.steps.findIndex((kept) => kept.title === step) + 1]?.title;
@@ -2124,7 +2260,7 @@ async function writtenNow(repo) {
 }
 // src/flows.ts
 const recorder = join(dirname(createRequire(import.meta.url).resolve("@rrweb/record")), "record.umd.min.cjs");
-const WALKED = "walked.json";
+const FORK_RAN = "fork.json";
 const ALONGSIDE = Symbol.for("playthrough: flows taken over here");
 const REACHES_OUTSIDE = "reaches outside";
 const waitsFor = ({ before }) => before ? 3e3 : 1e4;
@@ -2294,7 +2430,7 @@ async function runOnce(run) {
 		await rm(folder, { recursive: true });
 	}
 }
-async function walkFork(repo, id, walk) {
+async function runFork(repo, id, fork) {
 	const app = await repo.app();
 	const { started } = await repo.reviews.get(id);
 	const folder = await mkdtemp(join(tmpdir(), "playthrough-"));
@@ -2308,20 +2444,19 @@ async function walkFork(repo, id, walk) {
 			before: false,
 			taken: [],
 			started,
-			walk
+			fork
 		});
-		const text = await readFile(join(folder, WALKED), "utf8").catch(() => void 0);
+		const text = await readFile(join(folder, FORK_RAN), "utf8").catch(() => void 0);
 		if (!text) return void 0;
-		const walked = JSON.parse(text);
-		const files = await Promise.all([...new Set(Object.values(walked.assets))].map(async (name) => ({
+		const ran = JSON.parse(text);
+		const files = await Promise.all([...new Set(Object.values(ran.assets))].map(async (name) => ({
 			name,
 			bytes: await readFile(join(folder, name))
 		})));
-		const pictures = await Promise.all(walk.look.map((_, i) => readFile(join(folder, `look-${i}.png`)).catch(() => void 0)));
 		return {
-			...walked,
+			...ran,
 			files,
-			pictures
+			picture: await readFile(join(folder, "end.png")).catch(() => void 0)
 		};
 	} finally {
 		await rm(folder, {
@@ -2365,4 +2500,4 @@ async function playwright(run) {
 		});
 	});
 }
-export { repo as A, changes as C, personIn as D, make as E, setupIn as O, stopApp as S, giveBackLeft as T, compareWithEarlier as _, failedAt as a, keepRunning as b, isFlow as c, runFlows as d, waitsFor as f, writtenNow as g, trySetup as h, called as i, pausedAt as j, copies as k, makeFlowsFolder as l, whereItStopped as m, REACHES_OUTSIDE as n, flowsOf as o, walkFork as p, WALKED as r, howToWriteFlows as s, ALONGSIDE as t, recorder as u, placeIn as v, firstOf$1 as w, serves as x, shownAt as y };
+export { setupIn as A, serves as C, giveBackLeft as D, firstOf$1 as E, pausedAt as F, repo as M, stillAt as N, make as O, thisCommand as P, keepRunning as S, changes as T, compareWithEarlier as _, failedAt as a, sameWords as b, isFlow as c, runFlows as d, runFork as f, writtenNow as g, trySetup as h, called as i, copies as j, personIn as k, makeFlowsFolder as l, whereItStopped as m, FORK_RAN as n, flowsOf as o, waitsFor as p, REACHES_OUTSIDE as r, howToWriteFlows as s, ALONGSIDE as t, recorder as u, firstShown as v, stopApp as w, shownAt as x, placeIn as y };