playthrough 0.1.0 → 0.2.0

package/INSTRUCTIONS.md

@@ -90,14 +90,15 @@ page, Playwright's request and the app's address as baseURL, and what it returns
   }
 
   export async function after({ request, setup }: { request: APIRequestContext; baseURL: string; setup: Record<string, any> }) {
-    await request.delete(`/api/test/accounts/${setup.account}`);
+    const removed = await request.delete(`/api/test/accounts/${setup.account}`);
+    if (!removed.ok()) throw new Error(`Removing the account failed: ${removed.status()}`);
   }
 
 Each run makes its own, so give it back: after, if setup.ts exports it, runs once the run is over (a flow recorded, the
 app taken over and let go), given a request of its own and what the default export returned, so return what's needed to
-find and remove it, and sign in again there if removing it needs that. What a run made and didn't give back, because
-Playthrough was stopped, the next command gives back. What can't be taken back, like an email sent, avoid instead: test
-keys, a mail catcher.
+find and remove it, and sign in again there if removing it needs that. Check what each request answers, so one that
+fails says so rather than leaving it behind. What a run made and didn't give back, because Playthrough was stopped, the
+next command gives back. What can't be taken back, like an email sent, avoid instead: test keys, a mail catcher.
 
 Use what the project has (a test account, seed data, a reset hook, its own test fixtures, imported rather than copied),
 make data through the app's API or database rather than on screen, and stub what you can't control at the network. Sign
@@ -105,6 +106,13 @@ in with page.request, not request: it shares the page's cookies, so the page is
 the flow over. 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.
 
+The first time flows run in an app, and whenever app.json or setup.ts changes, Playthrough tries them first, and records
+nothing yet: it starts the app, makes what a flow starts from for each of the app's people twice, giving it back each
+time, and says what it found, with a picture of where each starts. Look at the pictures, fix what they show, and run the
+command again. It's the person's app, so tell them how flows get into it and what's missing, and ask before you change
+it for Playthrough's sake, as with a route only for tests, or when only they have what's needed, like a test account;
+the review doesn't wait for their answer.
+
 Each new flow is recorded twice. What changes by itself between the two, like a time the server stamps, is left out of
 every comparison, in every flow, and Playthrough says what it is: steady it in playthrough/setup.ts if you can, because a real
 change to it won't be seen.

package/package.json

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

package/src/playthrough.js

@@ -1,9 +1,9 @@
 #!/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 giveBackOwn, h as giveBackLeft, i as ALONGSIDE, j as roundInProgress, k as notesToAnswer, l as isFlow, p as whereItStopped, s as failedAt, t as read, u as makeFlowsFolder, w as Refused, x as compareWithEarlier, y as setupIn } from "./read-BBNVC-oH.js";
-import { d as firstLine, m as readingsOn } from "./reporter-Biym3TnN.js";
+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 { createRequire } from "node:module";
 import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { execFileSync, spawn } from "node:child_process";
+import { execFileSync } from "node:child_process";
 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";
@@ -575,42 +575,6 @@ async function recorded(repo, id) {
 	if (!round) throw new Refused([`${id} has nothing recorded yet, so there's nothing to take over. Record it first: playthrough record ${id}`]);
 	return round;
 }
-let started;
-let ending = false;
-async function keepRunning(app, root) {
-	if (!ending) {
-		ending = true;
-		const { setup, borrowed } = repo(root);
-		const giveBack = () => setupIn(setup).then((setup) => giveBackOwn(setup, borrowed));
-		const end = (signal) => void Promise.race([giveBack(), new Promise((wait) => setTimeout(wait, 1e4))]).finally(() => process.exit(128 + constants.signals[signal]));
-		for (const signal of [
-			"SIGINT",
-			"SIGTERM",
-			"SIGHUP"
-		]) process.once(signal, end);
-	}
-	if (await answers(app.url)) return;
-	console.log(`Starting the app: ${app.start}`);
-	started = spawn(app.start, {
-		cwd: root,
-		shell: true,
-		stdio: "ignore",
-		detached: true
-	});
-	const stop = () => {
-		try {
-			process.kill(-started.pid);
-		} catch {}
-	};
-	process.once("exit", stop);
-	for (let waited = 0; waited < 180; waited++) {
-		if (await answers(app.url)) return;
-		await new Promise((resolve) => setTimeout(resolve, 1e3));
-	}
-	stop();
-	throw new Refused([`The app didn't answer at ${app.url} within three minutes of ${quote(app.start)}. Check that playthrough/app.json starts it there.`]);
-}
-const answers = (url) => fetch(url, { signal: AbortSignal.timeout(2e3) }).then(() => true, () => false);
 function passOn(app, handed) {
 	const target = new URL(app.url);
 	const server = createServer((request, response) => {

package/src/{read-BBNVC-oH.js → read-C9bKWxxP.js}

@@ -1,17 +1,17 @@
-import { d as firstLine, f as glimpsesOf, p as readingsOf } from "./reporter-Biym3TnN.js";
+import { d as firstLine, f as glimpsesOf, p as readingsOf } from "./reporter-CECNk7aW.js";
 import { createRequire } from "node:module";
 import { existsSync, watch } from "node:fs";
 import { z } from "zod";
 import { spawn } from "node:child_process";
-import { tmpdir } from "node:os";
+import { constants, tmpdir } from "node:os";
 import { dirname, join, relative } from "node:path";
-import { mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { chromium, request } from "@playwright/test";
 import { createHash, randomUUID } from "node:crypto";
 // ../review/src/model.ts
 const text = (error) => z.string({ error }).refine((value) => value.trim() !== "", { error });
-const seconds = (error) => z.number({ error }).min(0, { error });
+const seconds$1 = (error) => z.number({ error }).min(0, { error });
 const share = (error) => z.number({ error }).min(0, { error }).max(1, { error });
 const fileName = (error) => z.string({ error }).regex(/^[\w.-]+(\/[\w.-]+)*$/, { error }).refine((name) => !name.split("/").some((part) => part === "." || part === ".."), { error });
 const Element$1 = z.strictObject({
@@ -43,8 +43,8 @@ const Did = z.strictObject({
 });
 const Place = z.strictObject({
 	flow: text("needs the flow it's on"),
-	at: seconds("needs its moment, in seconds").optional().describe("Without it, the whole flow"),
-	until: seconds("needs its end, in seconds").optional().describe("The end of a stretch"),
+	at: seconds$1("needs its moment, in seconds").optional().describe("Without it, the whole flow"),
+	until: seconds$1("needs its end, in seconds").optional().describe("The end of a stretch"),
 	element: Element$1.optional(),
 	alike: z.array(Element$1).optional().describe("The other things changed alike with its element, each where it is"),
 	box: Box.optional().describe("Something with no words of its own, or where only the pixels changed"),
@@ -52,7 +52,7 @@ const Place = z.strictObject({
 	app: z.strictObject({
 		from: z.strictObject({
 			flow: text("needs the flow it was taken over in"),
-			at: seconds("needs the moment it was taken over at, in seconds")
+			at: seconds$1("needs the moment it was taken over at, in seconds")
 		}),
 		did: z.array(Did).describe("What the person did there, in order"),
 		recording: fileName("needs its recording: the name of a file in the round").describe("The flow up to where it was taken over, then the person's own steps"),
@@ -65,8 +65,8 @@ const Place = z.strictObject({
 ].filter((thing) => thing).length <= 1, { error: "is on more than one thing. Choose an element, a box or a point" }).refine((place) => place.at !== void 0 || !(place.element || place.box || place.point), { error: "is on something but at no moment. Give it one" }).refine((place) => place.until === void 0 || place.at !== void 0 && place.until > place.at, { error: "ends before it starts. A stretch ends after its moment" });
 const Step = z.strictObject({
 	title: text("needs a title").describe("Steps are matched across rounds by their title"),
-	at: seconds("needs the moment it starts, in seconds"),
-	actions: z.array(seconds("needs the moment each of its actions was done, in seconds")).optional().describe("When each of its actions was done: between them the page rests, and a person can take the flow over there"),
+	at: seconds$1("needs the moment it starts, in seconds"),
+	actions: z.array(seconds$1("needs the moment each of its actions was done, in seconds")).optional().describe("When each of its actions was done: between them the page rests, and a person can take the flow over there"),
 	person: text("needs the name of who does it, or no person").optional().describe("Who does it, once the flow has changed hands: someone other than who the flow is done as")
 });
 const Flow = z.strictObject({
@@ -2102,6 +2102,7 @@ const isMissing = (error) => error.code === "ENOENT";
 // src/repo.ts
 function repo(root = process.cwd()) {
 	const reviews = join(root, ".playthrough");
+	const appFile = join(root, "playthrough", "app.json");
 	return {
 		root,
 		reviews: new Reviews(folder(reviews)),
@@ -2109,17 +2110,18 @@ function repo(root = process.cwd()) {
 		failed: (review) => join(reviews, review, "failed"),
 		round: (review, round) => join(reviews, review, "rounds", String(round), "round.json"),
 		setAside: join(reviews, "set-aside.json"),
+		appFile,
 		setup: join(root, "playthrough", "setup.ts"),
 		borrowed: join(reviews, "borrowed"),
+		tried: join(reviews, "tried"),
 		show: (path) => relative(process.cwd(), path) || ".",
 		async keepOutOfGit() {
 			await mkdir(reviews, { recursive: true });
 			await writeFile(join(reviews, ".gitignore"), "*\n");
 		},
 		async app() {
-			const file = join(root, "playthrough", "app.json");
 			const how = `Say how to start the app in playthrough/app.json: { "start": "<the command that serves it>", "url": "<where it's served>" }.`;
-			const text = await readFile(file, "utf8").catch(() => void 0);
+			const text = await readFile(appFile, "utf8").catch(() => void 0);
 			if (text === void 0) throw new Refused([`Playthrough needs to start the app to record it. ${how}`]);
 			let app;
 			try {
@@ -2156,7 +2158,7 @@ async function make({ make, after }, borrowed, given) {
 	const setup = await make?.(given) ?? {};
 	if (!after) return {
 		setup,
-		giveBack: async () => {}
+		giveBack: async () => false
 	};
 	await mkdir(borrowed, { recursive: true });
 	const file = join(borrowed, `${process.pid}-${randomUUID()}.json`);
@@ -2183,21 +2185,23 @@ async function giveBackOf({ after }, borrowed, whose) {
 }
 const giving = /* @__PURE__ */ new Set();
 async function giveBack(after, file, baseURL, setup) {
-	if (giving.has(file) || !existsSync(file)) return;
+	if (giving.has(file) || !existsSync(file)) return true;
 	giving.add(file);
-	const request$1 = await request.newContext({ baseURL });
+	const request$2 = await request.newContext({ baseURL });
 	try {
 		await after({
-			request: request$1,
+			request: request$2,
 			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.`);
+		return false;
 	} finally {
 		giving.delete(file);
-		await request$1.dispose();
+		await request$2.dispose();
 	}
 }
 function alive(pid) {
@@ -2208,6 +2212,155 @@ function alive(pid) {
 		return error.code === "EPERM";
 	}
 }
+// src/app.ts
+let started;
+let ending = false;
+async function keepRunning(app, root) {
+	if (!ending) {
+		ending = true;
+		const { setup, borrowed } = repo(root);
+		const giveBack = () => setupIn(setup).then((setup) => giveBackOwn(setup, borrowed));
+		const end = (signal) => void Promise.race([giveBack(), new Promise((wait) => setTimeout(wait, 1e4))]).finally(() => process.exit(128 + constants.signals[signal]));
+		for (const signal of [
+			"SIGINT",
+			"SIGTERM",
+			"SIGHUP"
+		]) process.once(signal, end);
+	}
+	if (await answers(app.url)) return;
+	console.log(`Starting the app: ${app.start}`);
+	const began = Date.now();
+	started = spawn(app.start, {
+		cwd: root,
+		shell: true,
+		stdio: "ignore",
+		detached: true
+	});
+	started.unref();
+	let ended = false;
+	started.once("exit", () => ended = true);
+	const stop = () => {
+		try {
+			process.kill(-started.pid);
+		} catch {}
+	};
+	process.once("exit", stop);
+	while (Date.now() - began < 18e4) {
+		if (await answers(app.url)) return Date.now() - began;
+		if (ended) throw new Refused([`${quote(app.start)} ended before the app answered at ${app.url}. Run it yourself to see why, and check that playthrough/app.json starts the app there.`]);
+		await new Promise((resolve) => setTimeout(resolve, 250));
+	}
+	stop();
+	throw new Refused([`The app didn't answer at ${app.url} within three minutes of ${quote(app.start)}. Check that playthrough/app.json starts it there.`]);
+}
+const answers = (url) => fetch(url, { signal: AbortSignal.timeout(2e3) }).then(() => true, () => false);
+// src/try-setup.ts
+const SLOW = 2e3;
+async function trySetup(repo, again) {
+	const app = await repo.app();
+	const written = await writtenNow(repo);
+	const last = join(repo.tried, "tried.json");
+	if (await readFile(last, "utf8").then((text) => JSON.parse(text).written, () => void 0) === written) return;
+	console.log("Trying the app's setup by itself first, twice, as every flow will start…");
+	const startedIn = await keepRunning(app, repo.root);
+	const setup = await setupIn(repo.setup, (await stat(repo.setup).catch(() => void 0))?.mtimeMs);
+	await giveBackLeft(setup, repo.borrowed);
+	await rm(repo.tried, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(repo.tried, { recursive: true });
+	const browser = await chromium.launch().catch((error) => {
+		if (/Executable doesn't exist/.test(String(error?.message))) throw new Refused(["Playwright has no Chromium to run the flows in yet. Install it (npx playwright install chromium), then run this again."]);
+		throw error;
+	});
+	const people = Object.keys(setup.people ?? {});
+	const tried = [];
+	try {
+		for (const person of people.length ? people : [void 0]) tried.push(await tryAs(repo, browser, setup, app.url, person));
+	} finally {
+		await browser.close();
+	}
+	const width = Math.max(7, ...tried.map(({ who }) => who.length)) + 3;
+	const line = (label, said) => `  ${label.padEnd(width)}${said}`;
+	console.log(`\n${line("The app", startedIn === void 0 ? `running already at ${app.url}` : `started with ${quote(app.start)}, answering at ${app.url} in ${seconds(startedIn)}`)}`);
+	for (const { who, did, took, at, picture } of tried) console.log(line(who, `${did}${did === "nothing made" ? "" : ` in ${seconds(took)}`}, then at ${at}: ${repo.show(picture)}`));
+	const missing = [];
+	if (!setup.make && !setup.signIn) missing.push("There's no playthrough/setup.ts, so each flow starts on whatever the app holds, as the flow before it left it, signed in as nobody.");
+	else if (!setup.after) 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(`Each flow waits up to ${seconds(slowest)} for its setup 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, or anything a flow shouldn't start from, is for playthrough/setup.ts.`);
+	if (missing.length) console.log(`
+${missing.map((said) => `- ${said}`).join("\n")}
+
+Tell the person now, in a few lines, how flows get into their app, and for each of these, what it costs them and the step that would fix it: something the app has already, or something only they can give, like a test account. Ask before you change their app for it, as with a route only for tests, and don't wait for their answer.`);
+	else console.log(`\nTell the person in a line or two how flows get into their app.`);
+	await writeFile(last, JSON.stringify({ written }));
+	throw new Refused([`\nNothing's recorded yet. Once ${tried.length > 1 ? "each picture shows" : "the picture shows"} where a flow should start, run ${again} again.`]);
+}
+async function tryAs(repo, browser, setup, baseURL, person) {
+	const tried = {
+		who: person ? person.charAt(0).toUpperCase() + person.slice(1) : "A flow",
+		did: setup.make && person && setup.signIn ? "made and signed in" : setup.make ? "made" : person && setup.signIn ? "signed in" : "nothing made",
+		took: 0,
+		at: "",
+		picture: join(repo.tried, `${(person ?? "a flow").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "person"}.png`),
+		givenBack: true
+	};
+	for (const time of ["first", "second"]) {
+		const context = await browser.newContext({
+			baseURL,
+			locale: "en-US",
+			timezoneId: "UTC",
+			viewport: {
+				width: 1280,
+				height: 800
+			}
+		});
+		const page = await context.newPage();
+		const request$1 = await request.newContext({ baseURL });
+		let made;
+		try {
+			const began = Date.now();
+			try {
+				made = await make(setup, repo.borrowed, {
+					page,
+					request: request$1,
+					baseURL,
+					person
+				});
+				if (person) await setup.signIn?.({
+					page,
+					person,
+					setup: made.setup
+				});
+			} catch (error) {
+				const why = firstLine(String(error?.message ?? error));
+				const as = person ? ` for ${quote(person)}` : "";
+				throw new Refused([time === "first" ? `playthrough/setup.ts couldn't make what a flow starts from${as}: ${why}. Fix it and run this again.` : `playthrough/setup.ts made what a flow starts from${as} once, but not a second time: ${why}. Each run makes its own, so make it new each time, as with a name or an email of its own, and run this again.`]);
+			}
+			tried.took = Math.max(tried.took, Date.now() - began);
+			if (page.url() === "about:blank") await page.goto("/");
+			await page.waitForLoadState("networkidle", { timeout: 5e3 }).catch(() => {});
+			const url = new URL(page.url());
+			tried.at = url.origin === new URL(baseURL).origin ? `${url.pathname}${url.search}` : url.href;
+			if (time === "second") await page.screenshot({ path: tried.picture });
+		} finally {
+			await context.close();
+			await request$1.dispose();
+			if (made && setup.after && !await made.giveBack()) tried.givenBack = false;
+		}
+	}
+	return tried;
+}
+const seconds = (ms) => ms < 100 ? "under 0.1 s" : `${(ms / 1e3).toFixed(1)} s`;
+async function writtenNow(repo) {
+	const text = (path) => readFile(path, "utf8").catch(() => "");
+	return createHash("sha256").update(await text(repo.appFile)).update("\0").update(await text(repo.setup)).digest("hex");
+}
 // src/flows.ts
 const WALKED = "walked.json";
 const ALONGSIDE = Symbol.for("playthrough: flows taken over here");
@@ -2221,6 +2374,7 @@ async function makeFlowsFolder(repo, id) {
 const isFlow = (name) => /\.[cm]?[jt]s$/.test(name);
 function howToWriteFlows(repo, id) {
 	const setupMissing = !existsSync(repo.setup);
+	const missing = !existsSync(repo.appFile) ? `, and how to start the app in playthrough/app.json. This app has ${setupMissing ? "neither" : "no app.json"} yet: run playthrough alone for how. Playthrough tries them before it records anything.` : setupMissing ? ", which this app doesn't have yet: run playthrough alone for how." : ".";
 	return `Each flow is a Playwright test in ${repo.show(repo.flows(id))}, one for each thing a person does, with a step for each part of it:
 
   import { test, expect } from "playthrough/test";
@@ -2235,13 +2389,14 @@ function howToWriteFlows(repo, id) {
   });
 
 The test's name is the flow's, and steps are matched across rounds by their names. What every flow starts from, like
-the account it opens, is made in playthrough/setup.ts${setupMissing ? ", which this app doesn't have yet" : ""}: run playthrough alone for how.`;
+the account it opens, is made in playthrough/setup.ts${missing}`;
 }
 async function runFlows(repo, id, round, { later, first }) {
 	const flows = repo.flows(id);
 	if (!(await readdir(flows).catch(() => [])).some(isFlow)) throw new Refused([`${id} has no flows yet. ${howToWriteFlows(repo, id)}`]);
 	await makeFlowsFolder(repo, id);
 	const app = await repo.app();
+	if (!later) await trySetup(repo, round === 0 ? `playthrough start ${id}` : `playthrough record ${id}`);
 	const { started, rounds } = await repo.reviews.get(id);
 	const recorder = join(dirname(createRequire(import.meta.url).resolve("@rrweb/record")), "record.umd.min.cjs");
 	const longest = (rounds.filter((kept) => kept.number < round).at(-1)?.flows ?? []).toSorted((a, b) => b.length - a.length).map((flow) => flow.name);
@@ -2657,4 +2812,4 @@ function read() {
 		things
 	};
 }
-export { problemsFinishing as A, shownAt as C, conversation as D, allNotes as E, list as M, quote as N, lastSeen as O, time as P, placeIn as S, pausedAt as T, make as _, REACHES_OUTSIDE as a, repo as b, howToWriteFlows as c, runFlows as d, walkFork as f, giveBackOwn as g, giveBackLeft as h, ALONGSIDE as i, roundInProgress as j, notesToAnswer as k, isFlow as l, firstOf as m, readPage as n, WALKED as o, whereItStopped as p, unhovered as r, failedAt as s, read as t, makeFlowsFolder as u, personIn as v, Refused as w, compareWithEarlier as x, setupIn as y };
+export { problemsFinishing as A, shownAt as C, conversation as D, allNotes as E, list as M, quote as N, lastSeen as O, time as P, placeIn as S, pausedAt as T, make as _, REACHES_OUTSIDE as a, repo as b, howToWriteFlows as c, runFlows as d, walkFork as f, giveBackLeft as g, firstOf as h, ALONGSIDE as i, roundInProgress as j, notesToAnswer as k, isFlow as l, keepRunning as m, readPage as n, WALKED as o, whereItStopped as p, unhovered as r, failedAt as s, read as t, makeFlowsFolder as u, personIn as v, Refused as w, compareWithEarlier as x, setupIn as y };

package/src/{reporter-Biym3TnN.js → reporter-CECNk7aW.js}

@@ -60,7 +60,10 @@ async function readingsOn(reviews, review, round, flow) {
 }
 const picturesOf = (flow) => `readings/${flow.recording.replace(/\.json$/, "")}`;
 const glimpsesOf = (flow) => `${picturesOf(flow)}.glimpses.json`;
-const firstLine = (said) => said.replace(/\x1b\[[0-9;]*m/g, "").split("\n")[0]?.trim();
+function firstLine(said) {
+	const line = said.replace(/\x1b\[[0-9;]*m/g, "").split("\n")[0]?.trim() ?? "";
+	return line.length > 300 ? `${line.slice(0, 300)}…` : line;
+}
 const BROKEN = /Page crashed|Target crashed|Target page, context or browser has been closed|net::ERR_CONNECTION_REFUSED/;
 var Flows = class {
 	#folder;

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, r as default, d as firstLine, f as glimpsesOf, p as readingsOf, m as readingsOn, h as seconds } from "./reporter-Biym3TnN.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, r as default, d as firstLine, f as glimpsesOf, p as readingsOf, m as readingsOn, h as seconds } from "./reporter-CECNk7aW.js";

package/src/test.js

@@ -1,5 +1,5 @@
-import { _ as make, a as REACHES_OUTSIDE, b as repo, i as ALONGSIDE, m as firstOf, n as readPage, o as WALKED, r as unhovered, v as personIn, y as setupIn } from "./read-BBNVC-oH.js";
-import { a as HANDS, c as PICTURE, d as firstLine, g as keepAssets, h as seconds, i as GLIMPSES, l as READINGS, n as ASSETS, o as HOLD, s as PERSON, t as ACTIONS, u as RECORDING } from "./reporter-Biym3TnN.js";
+import { _ as make, a as REACHES_OUTSIDE, b as repo, h as firstOf, i as ALONGSIDE, n as readPage, o as WALKED, r as unhovered, v as personIn, y as setupIn } from "./read-C9bKWxxP.js";
+import { a as HANDS, c as PICTURE, d as firstLine, g as keepAssets, h as seconds, i as GLIMPSES, l as READINGS, n as ASSETS, o as HOLD, s as PERSON, t as ACTIONS, u as RECORDING } from "./reporter-CECNk7aW.js";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";

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

@@ -0,0 +1,2 @@
+import { type App } from "./repo.js";
+export declare function keepRunning(app: App, root: string): Promise<number | undefined>;

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

@@ -11,8 +11,10 @@ export declare function repo(root?: string): {
     failed: (review: string) => string;
     round: (review: string, round: number) => string;
     setAside: string;
+    appFile: string;
     setup: string;
     borrowed: string;
+    tried: string;
     show: (path: string) => string;
     keepOutOfGit(): Promise<void>;
     app(): Promise<App>;

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

@@ -13,7 +13,7 @@ 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[]>;
 export declare const glimpsesOf: (flow: Flow) => string;
-export declare const firstLine: (said: string) => string;
+export declare function firstLine(said: string): string;
 export type Failed = {
     flow: string;
     at?: string;

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

@@ -27,7 +27,7 @@ export declare const firstOf: ({ people }: Setup) => string;
 export declare function personIn({ people }: Setup, person: string): void;
 export type Made = {
     setup: Record<string, any>;
-    giveBack: () => Promise<void>;
+    giveBack: () => Promise<boolean>;
 };
 export declare function make({ make, after }: Setup, borrowed: string, given: Parameters<Make>[0] & {
     baseURL: string;

package/types/cli/src/try-setup.d.ts

@@ -0,0 +1,2 @@
+import type { Repo } from "./repo.js";
+export declare function trySetup(repo: Repo, again: string): Promise<void>;