playthrough 0.3.0 → 0.3.1

package/INSTRUCTIONS.md

@@ -20,13 +20,14 @@ THE LOOP
    name. Once the work is done, add a flow for each choice you made that the person can see and didn't ask for.
 4. playthrough record <review> records the round and compares it 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 note it was made for>" }, or { "notReal": "<why nothing really changed>" }.
+   { "note": "<the id of the note it was made for>" }, or { "notReal": "<why nothing really changed>" }.
 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". 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.
+   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.
 
 The person can only judge what the flows show, so keep them true to how a person uses the app.
 
@@ -91,15 +92,16 @@ tells tests by (the screen, language and time zone are Playthrough's):
 
   export async function after({ request, setup }: { request: APIRequestContext; baseURL: string; setup: Record<string, any> }) {
     const removed = await request.delete(`/api/test/accounts/${setup.account}`);
-    if (!removed.ok()) throw new Error(`Removing the account failed: ${removed.status()}`);
+    if (!removed.ok() && removed.status() !== 404) throw new Error(`Removing the account failed: ${removed.status()}`);
   }
 
 Each run makes its own: what the app needs unique, like an email, of its own, and what the page shows, like a name, the
-same every run. Check what each request answers, so one that fails says so. Avoid what can't be given back, like an
-email sent: test keys, a mail catcher. Use what the project has (a test account, seed data, its own fixtures), make data
-through the API or database rather than on screen, and stub what you can't control at the network. Sign in with
-page.request, not request: it shares the page's cookies, so a person who takes the flow over is signed in too. Dates
-the server works out don't follow the page's clock: fix them through the app's own test hook if it has one.
+same every run. Check what each request answers, so one that fails says so. An after that fails is tried again whole by
+the next command, so it takes what's gone already as given back. Avoid what can't be given back, like an email sent:
+test keys, a mail catcher. Use what the project has (a test account, seed data, its own fixtures), make data through the
+API or database rather than on screen, and stub what you can't control at the network. Sign in with page.request, not
+request: it shares the page's cookies, so a person who takes the flow over is signed in too. Dates the server works out
+don't follow the page's clock: fix them through the app's own test hook if it has one.
 
 Whenever app.json or setup.ts changes, Playthrough tries the setup by itself first, twice for each of the app's people,
 and shows a picture of where each starts. Fix what the pictures show and run the command again. It's the person's app:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playthrough",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Review an AI agent's work on a web app by watching recordings of it.",
   "type": "module",
   "license": "Apache-2.0",

package/src/{flows-Dt7fcPLt.js → flows-BcISV1M-.js}

@@ -1,4 +1,4 @@
-import { O as list, b as Refused, g as readingsOf, k as quote, m as glimpsesOf, p as firstLine, x as Reviews } from "./reporter-4C_7joIm.js";
+import { C as Refused, M as list, N as quote, h as glimpsesOf, m as firstLine, w as Reviews, y as readingsOf } from "./reporter-BEodHYRI.js";
 import * as modules from "node:module";
 import { createRequire } from "node:module";
 import { existsSync, watch } from "node:fs";
@@ -268,7 +268,7 @@ async function giveBack(after, file, baseURL, setup) {
 		await rm(file, { force: true });
 		return true;
 	} catch (error) {
-		console.log(`playthrough/setup.ts's after couldn't give back what a run made: ${firstLine(String(error?.message ?? error))}. It's tried again by the next command.`);
+		console.log(`playthrough/setup.ts's after couldn't give back what a run made: ${firstLine(String(error?.message ?? error))}. The next command tries it again, whole, so it should take what's gone already as given back.`);
 		return false;
 	} finally {
 		giving.delete(file);
@@ -730,7 +730,7 @@ function placeIn(place, from, to) {
 	};
 	if (place.point) return {
 		...moment,
-		point: place.point
+		point: besideOn(place.point, place.at, from, to) ?? place.point
 	};
 	const there = (element) => {
 		const found = foundIn(from.readings, element, place.at, to.readings);
@@ -744,6 +744,36 @@ function placeIn(place, from, to) {
 		...alike?.length && { alike }
 	} : moment;
 }
+const HOLDING = /^(dialog|alertdialog|group|radiogroup|table|grid|treegrid|listbox|menu)$/;
+function besideIn(read, at, point) {
+	const reading = read.reduce((best, next) => !best || Math.abs(next.at - at) < Math.abs(best.at - at) ? next : best, void 0);
+	if (!reading) return void 0;
+	const x = point.x * reading.screen.width;
+	const y = point.y * reading.screen.height;
+	const inside = (thing) => x >= thing.box.x && x <= thing.box.x + thing.box.width && y >= thing.box.y && y <= thing.box.y + thing.box.height;
+	const area = (thing) => thing.box.width * thing.box.height;
+	const room = reading.things.filter((thing) => (thing.role === "box" || HOLDING.test(thing.role) && !/^(table|grid|treegrid)$/.test(thing.role)) && inside(thing)).sort((a, b) => area(a) - area(b))[0];
+	const within = (thing) => {
+		for (let holder = thing.holder; holder !== void 0; holder = reading.things[holder]?.holder) if (reading.things[holder] === room) return true;
+		return false;
+	};
+	const gap = (thing) => Math.hypot(Math.max(thing.box.x - x, 0, x - thing.box.x - thing.box.width), Math.max(thing.box.y - y, 0, y - thing.box.y - thing.box.height));
+	const thing = reading.things.filter((thing) => thing.name && thing.role !== "box" && !HOLDING.test(thing.role) && (!room || within(thing)) && gap(thing) <= 80).sort((a, b) => gap(a) - gap(b) || area(a) - area(b))[0];
+	return thing && {
+		reading,
+		thing
+	};
+}
+function besideOn(point, at, from, to) {
+	const beside = besideIn(from.readings, at, point);
+	const found = beside && sameIn(beside, from.readings, to.readings);
+	if (!beside || !found) return void 0;
+	const share = (pixels, of) => Math.min(1, Math.max(0, pixels / of));
+	return {
+		x: share(point.x * beside.reading.screen.width + found.thing.box.x - beside.thing.box.x, found.reading.screen.width),
+		y: share(point.y * beside.reading.screen.height + found.thing.box.y - beside.thing.box.y, found.reading.screen.height)
+	};
+}
 function foundIn(from, element, at, to) {
 	const shown = shownAt(from, element, at);
 	return shown && sameIn(shown, from, to);
@@ -791,11 +821,13 @@ function changesAt(then, now, unsteady = /* @__PURE__ */ new Set(), shown = {
 	const others = own.filter((difference) => !isMove(difference));
 	const caused = grownByWhatsInside(moment, own);
 	const along = /* @__PURE__ */ new Map();
-	const { reordered, left } = rowsReordered(moment, own.filter(isMove));
+	const items = itemsReordered(moment, own.filter(isMove));
+	const { reordered, left } = rowsReordered(moment, items.left);
 	const { shifts, loose } = layoutShifts(left, carried);
 	moment.shifts = shifts.map((shift) => shift.by);
 	const widened = widenedTogether(others, caused, along);
 	const told = [
+		...items.reordered,
 		...reordered,
 		...swappedOrMoved(moment, loose),
 		...causesOfShifts(moment, shifts, widened, others, caused, along)
@@ -907,6 +939,76 @@ function grownByWhatsInside(moment, own) {
 	}
 	return caused;
 }
+function itemsReordered(moment, moves) {
+	const { then, now } = moment;
+	const pairs = pairItems(moment);
+	const reordered = [];
+	let left = moves;
+	for (const [, paired] of groupBy([...pairs], ([, b]) => now.items[b].list)) {
+		const byThen = [...paired].sort((p, q) => p[0] - q[0]);
+		const byNow = [...paired].sort((p, q) => p[1] - q[1]);
+		const placeThen = new Map(byThen.map(([a], i) => [a, i]));
+		const kept = longestRising(byNow.map(([a]) => placeThen.get(a)));
+		const way = (a, b) => {
+			const went = moveOf(asThing(then.items[a], a), asThing(now.items[b], b));
+			return Math.abs(went.y) >= Math.abs(went.x) ? went.y > 0 ? "down" : "up" : went.x > 0 ? "right" : "left";
+		};
+		const moved = byNow.flatMap(([a, b], i) => kept.has(i) ? [] : [{
+			thing: asThing(now.items[b], b),
+			way: way(a, b),
+			places: Math.abs(i - placeThen.get(a))
+		}]);
+		if (!moved.length) continue;
+		const changed = byNow.filter(([a], i) => placeThen.get(a) !== i);
+		const first = now.items[byNow[0][1]];
+		const of = `${first.role} of ${listOf(now, first)}`;
+		const holder = first.holder === void 0 ? void 0 : now.things[first.holder];
+		if (changed.length === 2) {
+			const both = changed.map(([, b]) => asThing(now.items[b], b));
+			reordered.push({
+				what: "swapped",
+				thing: both[0],
+				in: now,
+				words: `${together(both)} have swapped places`,
+				key: `${of}: ${both.map((thing) => thing.words).join(" / ")}`
+			});
+		} else if (moved.length <= 2) for (const { thing, way, places } of moved) reordered.push({
+			what: "moved",
+			thing,
+			in: now,
+			words: `${called$1(thing)} moved ${way} ${places} ${places > 1 ? "places" : "place"}`,
+			key: `${of}: ${thing.words}`
+		});
+		else {
+			const order = byNow.slice(0, 3).map(([, b]) => called$1(asThing(now.items[b], b)));
+			const words = first.role === "row" ? `Rows in ${holder ? the(holder) : "the table"} are in a new order` : `What's in ${holder ? the(holder) : "the list"} is in a new order: ${order.join(", ")}${byNow.length > 3 ? "…" : ""}`;
+			reordered.push({
+				what: "reordered",
+				thing: holder ?? moved[0].thing,
+				in: now,
+				words,
+				key: of
+			});
+		}
+		const inList = new Set(paired.map(([, b]) => b));
+		left = left.filter((move) => !(move.now.item !== void 0 && inList.has(move.now.item) && move.then.item !== void 0 && pairs.get(move.then.item) === move.now.item));
+	}
+	return {
+		reordered,
+		left
+	};
+}
+function longestRising(sequence) {
+	const best = sequence.map(() => 1);
+	const before = sequence.map(() => -1);
+	for (let i = 0; i < sequence.length; i++) for (let j = 0; j < i; j++) if (sequence[j] < sequence[i] && best[j] + 1 > best[i]) {
+		best[i] = best[j] + 1;
+		before[i] = j;
+	}
+	const kept = /* @__PURE__ */ new Set();
+	for (let i = best.indexOf(Math.max(...best)); i >= 0; i = before[i]) kept.add(i);
+	return kept;
+}
 function rowsReordered(moment, moves) {
 	const reordered = [];
 	let left = moves;
@@ -1229,8 +1331,10 @@ function identityOf({ in: reading, thing, what }, moment) {
 	if (!item) return identity(reading, thing);
 	const kind = reading.things.filter((other) => other.item === thing.item && other.role === thing.role && other.column === thing.column);
 	const place = `${thing.role} ${kind.indexOf(thing) + 1}${thing.column ? ` under ${thing.column}` : ""}`;
-	const was = what === "reworded" && moment.was.get(thing);
-	return `${place} in a ${item.role} of ${listOf(reading, item)}${was ? `: ${shapeOf(was.words, thing.words)}` : ""}`;
+	const was = /^(reworded|moved)$/.test(what) ? moment.was.get(thing) : void 0;
+	const went = was && what === "moved" && moveOf(was, thing);
+	const how = went ? `, ${wayOf(near(went.x, 0) ? 0 : went.x, near(went.y, 0) ? 0 : went.y)}` : was ? `: ${shapeOf(was.words, thing.words)}` : "";
+	return `${place} in a ${item.role} of ${listOf(reading, item)}${how}`;
 }
 const listOf = (reading, item) => item.holder === void 0 ? "the page" : identity(reading, reading.things[item.holder], 0);
 function pairItems({ then, now, was }) {
@@ -1455,9 +1559,10 @@ async function picturesAt(page, then, now, pictures) {
 		if (patch.nudged && found.length) continue;
 		if (patch.moved && [...changedInside].some((holder) => contains(holder.box, patch, 8))) continue;
 		const on = whatsThere(now, patch);
-		const by = patch.moved && Math.max(Math.abs(patch.moved.x), Math.abs(patch.moved.y));
-		const words = patch.moved ? `${on.called} moved ${wayOf(patch.moved.x, patch.moved.y)}, ${by}px` : `${on.called} looks different`;
-		const id = idOf(on.identity ?? `place:${Math.round(patch.x / 32)},${Math.round(patch.y / 32)}`, patch.moved ? "moved" : "looks different");
+		const moved = on.identity && !on.identity.startsWith("near ") ? void 0 : patch.moved;
+		const by = moved && Math.max(Math.abs(moved.x), Math.abs(moved.y));
+		const words = moved ? `${on.called} moved ${wayOf(moved.x, moved.y)}, ${by}px` : `${on.called} looks different`;
+		const id = idOf(on.identity ?? `place:${Math.round(patch.x / 32)},${Math.round(patch.y / 32)}`, moved ? "moved" : "looks different");
 		const same = told.get(id);
 		told.set(id, {
 			words,
@@ -1881,11 +1986,11 @@ async function trySetup(repo, again) {
 	for (const { who, did, took, at, refused, picture } of tried) console.log(line(who, `${did}${did === "nothing made" ? "" : ` in ${seconds(took)}`}, then at ${at}${refused ? `, which the app answered with ${refused}` : ""}: ${repo.show(picture)}`));
 	const missing = [];
 	if (!setup.after && tried.some(({ made }) => made)) missing.push("playthrough/setup.ts has no after, so what each run makes stays in the app: one for each flow recorded, two for a new one, and one each time the person pauses a recording, as it's made ready to take over.");
-	else if (tried.some(({ givenBack }) => !givenBack)) missing.push("playthrough/setup.ts's after couldn't give back what it made, for the reason above.");
 	const slowest = Math.max(...tried.map(({ took }) => took));
 	if (slowest > SLOW) missing.push(`Setup took ${seconds(slowest)}: each flow waits that long before its first step, and so does each moment taken over.`);
 	console.log(`
 Look at ${tried.length > 1 ? "each picture: it's where their flows start" : "the picture: it's where every flow starts"}. One that shows a sign-in page for someone who should be signed in, or anything a flow shouldn't start from, is for playthrough/setup.ts.`);
+	if (tried.some(({ givenBack }) => !givenBack)) console.log(`\nplaythrough/setup.ts's after couldn't give back what it made, for the reason above: that's for setup.ts too.`);
 	if (missing.length) console.log(`
 ${missing.map((said) => `- ${said}`).join("\n")}
 

package/src/playthrough.js

@@ -1,6 +1,6 @@
 #!/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 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, cpSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -239,9 +239,9 @@ 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 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 records a flow changed since on Before again.${where}`);
@@ -1531,13 +1531,15 @@ async function record(repo, id) {
 	]);
 	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) => ({
@@ -1567,7 +1569,7 @@ async function record(repo, id) {
 	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 && 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 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.`);

package/src/playwright.config.js

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

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

@@ -84,7 +84,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 +153,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, {
@@ -335,7 +338,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 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 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.`);
@@ -731,6 +734,7 @@ const HANDS = "playthrough hands";
 const ACTIONS = "playthrough actions";
 const WROTE = "playthrough wrote";
 const UNMET = "playthrough unmet";
+const STOPPED_ON = "playthrough stopped on";
 const HOLD = 1500;
 const readingsOf = (flow) => `readings/${flow.recording}`;
 async function readingsOn(reviews, review, round, flow) {
@@ -748,6 +752,11 @@ function firstLine(said) {
 	if (found.length) line = `${line} ${found.slice(0, 2).join(", ")}${found.length > 2 ? ", …" : ""}`;
 	return line.length > 300 ? `${line.slice(0, 300)}…` : line;
 }
+const pathOf = (address) => {
+	const { pathname, search } = new URL(address);
+	return pathname + search;
+};
+const onPage = (on) => on ? `, on ${on}` : "";
 const BROKEN = /Page crashed|Target crashed|Target page, context or browser has been closed|net::ERR_CONNECTION_REFUSED/;
 const hashOf = (file) => {
 	try {
@@ -809,11 +818,13 @@ var Flows = class {
 		const said = (stop?.error ?? result.error)?.message ?? "";
 		const broken = BROKEN.test(said);
 		const why = firstLine(said);
+		const on = result.attachments.find((attachment) => attachment.name === STOPPED_ON)?.body?.toString();
 		const failed = {
 			flow: test.title,
 			...stop?.error && { at: stop.title },
 			...why && { why },
-			...broken && { broken }
+			...broken && { broken },
+			...stop?.error && on && { on }
 		};
 		if (!this.#before || broken || !recording || !stop || !kept.length) {
 			this.#ran.push({
@@ -830,7 +841,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)}${onPage(failed.on)}` : "stops after its last step"}${yet}`);
 	}
 	onError(error) {
 		console.log(`\n${error.message ?? error.value}`);
@@ -916,4 +927,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 { problemsFinishing as A, Refused as C, inOrderJoined as D, conversation as E, list as M, quote as N, lastSeen as O, time as P, keepAssets as S, allNotes as T, onPage as _, HANDS as a, readingsOn as b, PICTURE as c, STOPPED_ON as d, UNMET as f, hashOf as g, glimpsesOf as h, GLIMPSES as i, roundInProgress as j, notesToAnswer as k, READINGS as l, firstLine as m, ASSETS as n, HOLD as o, WROTE as p, Flows as r, PERSON as s, ACTIONS as t, RECORDING as u, pathOf as v, Reviews as w, seconds as x, readingsOf 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, i as GLIMPSES, a as HANDS, o as HOLD, s as PERSON, c as PICTURE, l as READINGS, u as RECORDING, d as STOPPED_ON, f as UNMET, p as WROTE, r as default, m as firstLine, h as glimpsesOf, g as hashOf, _ as onPage, v as pathOf, y as readingsOf, b as readingsOn, x as seconds } from "./reporter-BEodHYRI.js";

package/src/test.js

@@ -1,5 +1,5 @@
-import { a as HANDS, c as PICTURE, d as UNMET, f as WROTE, i as GLIMPSES, l as READINGS, n as ASSETS, o as HOLD, p as firstLine, s as PERSON, t as ACTIONS, u as RECORDING, v as seconds, y as keepAssets } from "./reporter-4C_7joIm.js";
-import { C as make, E as repo, T as setupIn, b as changes, n as REACHES_OUTSIDE, r as WALKED, t as ALONGSIDE, w as personIn, x as firstOf } from "./flows-Dt7fcPLt.js";
+import { S as keepAssets, a as HANDS, c as PICTURE, d as STOPPED_ON, f as UNMET, i as GLIMPSES, l as READINGS, m as firstLine, n as ASSETS, o as HOLD, p as WROTE, s as PERSON, t as ACTIONS, u as RECORDING, v as pathOf, x as seconds } from "./reporter-BEodHYRI.js";
+import { C as make, E as repo, T as setupIn, b as changes, n as REACHES_OUTSIDE, r as WALKED, t as ALONGSIDE, w as personIn, x as firstOf } from "./flows-BcISV1M-.js";
 import { n as readPage, r as unhovered } from "./read-Bg9XVTtn.js";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -264,6 +264,10 @@ const recorded = test$1.extend({
 			body: String(flow.unmet),
 			contentType: "text/plain"
 		});
+		if (!ended && last.url() !== "about:blank") await testInfo.attach(STOPPED_ON, {
+			body: pathOf(last.url()),
+			contentType: "text/plain"
+		});
 		for (const picture of pictures) await testInfo.attach(PICTURE, {
 			body: picture,
 			contentType: "image/png"

package/types/cli/src/reporter.d.ts

@@ -11,6 +11,7 @@ export declare const HANDS = "playthrough hands";
 export declare const ACTIONS = "playthrough actions";
 export declare const WROTE = "playthrough wrote";
 export declare const UNMET = "playthrough unmet";
+export declare const STOPPED_ON = "playthrough stopped on";
 export declare const HOLD = 1500;
 export declare const readingsOf: (flow: Flow) => string;
 export declare function readingsOn(reviews: Reviews, review: string, round: number, flow: Flow): Promise<Reading[]>;
@@ -21,7 +22,10 @@ export type Failed = {
     at?: string;
     why?: string;
     broken?: true;
+    on?: string;
 };
+export declare const pathOf: (address: string) => string;
+export declare const onPage: (on?: string) => string;
 export type Recorded = {
     flow: Flow;
     files: string[];

package/types/page/src/found.d.ts

@@ -1,5 +1,5 @@
-import { type Element, type Flow, type Place } from "../../review/src/index.js";
-import type { Reading, Thing } from "./reading.js";
+import { type Element, type Flow, type Place, type Point } from "../../review/src/index.js";
+import type { Glimpse, Reading, Thing } from "./reading.js";
 export type Recorded = {
     flow: Flow;
     readings: Reading[];
@@ -9,5 +9,7 @@ export type Shown = {
     thing: Thing;
 };
 export declare function placeIn(place: Place, from: Recorded, to: Recorded): Place;
+export declare const HOLDING: RegExp;
+export declare const nearTo: (read: Glimpse[], at: number, point: Point) => Thing | undefined;
 export declare function shownAt(readings: Reading[], element: Element, at: number): Shown | undefined;
 export declare const elementOf: (thing: Thing, name: string) => Element;

package/types/review/src/rules.d.ts

@@ -1,5 +1,6 @@
 import { Comparison, Round, Send, type Account, type Flow, type Note, type Place, type Review, type Verdict } from "./model.js";
 export declare function roundInProgress(review: Review): number;
+export declare function inOrderJoined(review: Review): string[];
 export declare function allNotes(review: Review): Map<string, {
     note: Note;
     round: number;