playthrough 0.5.0 → 0.6.0

package/src/playwright.config.js

@@ -1,4 +1,4 @@
-import { f as waitsFor } from "./flows-DDB6AdQ-.js";
+import { p as waitsFor } from "./flows-CbrwgoHB.js";
 import { availableParallelism } from "node:os";
 import { defineConfig } from "@playwright/test";
 import { fileURLToPath } from "node:url";

package/src/{reporter-Dr7dWwSf.js → reporter-DlS7qehW.js}

@@ -50,7 +50,11 @@ const Place = z.strictObject({
 		}),
 		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"),
-		length: z.number({ error: "needs its length, in seconds" }).positive({ error: "needs its length, in seconds" })
+		length: z.number({ error: "needs its length, in seconds" }).positive({ error: "needs its length, in seconds" }),
+		steps: z.array(z.strictObject({
+			title: text("needs its title"),
+			at: seconds$1("needs its start, in seconds")
+		})).optional().describe("Run again as the agent wrote it, a fork of its flow: its steps, each at its start")
 	}).optional().describe("In the app: on the person's own recording, which branches off a flow where they took it over. Its flow names the branch")
 }).refine((place) => [
 	place.element,
@@ -76,6 +80,8 @@ const Flow = z.strictObject({
 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”"),
+	reworded: text("needs the words that read differently").optional().describe("For words reworded, the words that read differently now, which the viewer marks where they are: “on their own”"),
+	gone: z.literal(true).optional().describe("Not on the newer round: where it was, on the round before, is where it's seen, with Compare"),
 	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")
 });

package/src/reporter.js

@@ -1 +1 @@
-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 readingsOf, g as readingsOn, _ as seconds } from "./reporter-Dr7dWwSf.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 readingsOf, g as readingsOn, _ as seconds } from "./reporter-DlS7qehW.js";

package/src/test.js

@@ -1,5 +1,5 @@
-import { _ as seconds, a as GLIMPSES, c as PERSON, d as RECORDING, f as WROTE, l as PICTURE, n as ASSETS, o as HANDS, p as firstLine, r as DONE_ON, s as HOLD, t as ACTIONS, u as READINGS, v as keepAssets } from "./reporter-Dr7dWwSf.js";
-import { A as repo, C as changes, D as personIn, E as make, O as setupIn, n as REACHES_OUTSIDE, r as WALKED, t as ALONGSIDE, w as firstOf } from "./flows-DDB6AdQ-.js";
+import { _ as seconds, a as GLIMPSES, c as PERSON, d as RECORDING, f as WROTE, l as PICTURE, n as ASSETS, o as HANDS, p as firstLine, r as DONE_ON, s as HOLD, t as ACTIONS, u as READINGS, v as keepAssets } from "./reporter-DlS7qehW.js";
+import { A as setupIn, E as firstOf, M as repo, O as make, T as changes, b as sameWords, k as personIn, n as FORK_RAN, r as REACHES_OUTSIDE, t as ALONGSIDE } from "./flows-CbrwgoHB.js";
 import { n as readPage, r as unhovered } from "./read-Bg9XVTtn.js";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -92,15 +92,20 @@ function onlyWaits(expect) {
 const recorder = (rrweb) => `;((Date, setTimeout, clearTimeout, requestAnimationFrame, cancelAnimationFrame) => {
 ${readFileSync(rrweb, "utf8")}
 })(Date, setTimeout, clearTimeout, requestAnimationFrame, cancelAnimationFrame);
-if (window.top === window) window.rrwebRecord.record({
-  // Nothing is kept until the flow itself starts, after whatever the app's setup did on the page.
-  emit: (event) => window.__playthrough?.(event),
-  // every input, not just the last: with "last", rrweb only hears a field change when it loses focus,
-  // so words typed into a search box that kept focus never reached the recording
-  sampling: { mousemove: 20, scroll: 16, input: "all" },
-  maskAllInputs: false,
-  inlineStylesheet: true,
-});`;
+// With each page taken whole, whether its browser was light or dark, still or moving, for it to be played back as it
+// was: said once rrweb has the page, as said at its very start it went before anything was listening.
+const said = () => window.rrwebRecord.record.addCustomEvent("browser", { dark: matchMedia("(prefers-color-scheme: dark)").matches, still: matchMedia("(prefers-reduced-motion: reduce)").matches });
+if (window.top === window) {
+  window.rrwebRecord.record({
+    // Nothing is kept until the flow itself starts, after whatever the app's setup did on the page.
+    emit: (event) => (window.__playthrough?.(event), event.type === 2 && setTimeout(said)),
+    // every input, not just the last: with "last", rrweb only hears a field change when it loses focus,
+    // so words typed into a search box that kept focus never reached the recording
+    sampling: { mousemove: 20, scroll: 16, input: "all" },
+    maskAllInputs: false,
+    inlineStylesheet: true,
+  });
+}`;
 const FRAME = 16;
 const REST = 140;
 const KEY = 60;
@@ -133,7 +138,7 @@ const recorded = test$1.extend({
 	rest: async ({ page }, use) => use(run ? await watchRest(page) : async () => {}),
 	setup: async ({ page, request, baseURL, person, rest: _ }, use, testInfo) => {
 		if (run?.only && !run.only.includes(testInfo.title)) testInfo.skip();
-		if (run?.walk && testInfo.title !== run.walk.flow) testInfo.skip();
+		if (run?.fork && testInfo.title !== run.fork.flow) testInfo.skip();
 		const app = await setupOf();
 		if (person) personIn(app, person);
 		if (run) await readied(page, run);
@@ -171,7 +176,7 @@ const recorded = test$1.extend({
 		});
 		for (const context of opened) await context.close();
 	},
-	recorder: [async ({ page, setup, rest, person, handTo: _ }, use, testInfo) => {
+	recorder: [async ({ page, request, baseURL, setup, rest, person, handTo }, use, testInfo) => {
 		if (!run) return use();
 		testInfo.setTimeout(testInfo.timeout * 3);
 		const flow = {
@@ -186,7 +191,15 @@ const recorded = test$1.extend({
 			inStep: 0,
 			hands: [],
 			assets: [],
-			doneOn: {}
+			doneOn: {},
+			given: {
+				page,
+				context: page.context(),
+				request,
+				baseURL,
+				setup,
+				handTo
+			}
 		};
 		await page.exposeFunction("__playthrough", (event) => void (flow.page === page && flow.events.push(event)));
 		flow.assets.push(keepAssets(page, run.folder));
@@ -209,15 +222,20 @@ const recorded = test$1.extend({
 		}
 		const last = flow.page;
 		const assets = async () => Object.assign({}, ...await Promise.all(flow.assets.map((kept) => kept())));
-		if (run.walk) {
-			if (!flow.walked) return;
+		if (run.fork) {
+			if (!flow.forked) return;
 			await last.waitForTimeout(HOLD);
 			await last.evaluate(() => window.rrwebRecord.record.addCustomEvent("end", {}));
 			await last.waitForTimeout(100);
-			return writeFileSync(join(run.folder, WALKED), JSON.stringify({
-				...flow.walked,
+			writeFileSync(join(run.folder, "end.png"), await last.screenshot({
+				animations: "disabled",
+				caret: "hide"
+			}));
+			return writeFileSync(join(run.folder, FORK_RAN), JSON.stringify({
+				...flow.forked,
 				events,
 				readings,
+				glimpses,
 				assets: await assets()
 			}));
 		}
@@ -382,12 +400,17 @@ function answers(dialog) {
 	}
 }
 let collecting;
+let collectingForks = [];
 let around = [];
 let loading = Promise.resolve();
 function flowsIn(file, written) {
 	const flows = /* @__PURE__ */ new Map();
 	const loaded = loading.then(async () => {
-		[collecting, around] = [flows, [{ use: {} }]];
+		[collecting, around, collectingForks] = [
+			flows,
+			[{ use: {} }],
+			[]
+		];
 		try {
 			await import(`${pathToFileURL(file).href}?${written}`);
 		} finally {
@@ -401,7 +424,7 @@ function flowsIn(file, written) {
 const taking = new AsyncLocalStorage();
 const holds = (flow) => !flow.wrote && flow.page.url() === flow.address;
 var Stopped = class extends Error {};
-async function runAlongside(page, { request, baseURL, started, setup: appSetup, borrowed, arrived, person }, body, orders) {
+async function runAlongside(page, { request, baseURL, started, setup: appSetup, borrowed, arrived, person }, body, orders, forks = []) {
 	const readied = async (page) => {
 		const rest = await watchRest(page);
 		await page.clock.setSystemTime(onReviewDay(started));
@@ -415,6 +438,7 @@ async function runAlongside(page, { request, baseURL, started, setup: appSetup,
 	};
 	const flow = {
 		page,
+		forks,
 		depth: 0,
 		rest: async () => {},
 		actions: 0,
@@ -463,14 +487,15 @@ async function runAlongside(page, { request, baseURL, started, setup: appSetup,
 				person: who,
 				setup: made.setup
 			});
-			await body({
+			flow.given = {
 				page,
 				context: page.context(),
 				request,
 				baseURL,
 				setup: made.setup,
 				handTo
-			});
+			};
+			await body(flow.given);
 			await reached(flow);
 			return {
 				handed: flow.handed,
@@ -500,7 +525,7 @@ async function reached(flow, step, actions) {
 		if (stopped) throw new Stopped();
 		const where = against(flow.passed, step, actions, to);
 		if (where === "on") return;
-		if (where === "here" && to.rests) await handOver(flow, to.did);
+		if (where === "here" && to.rests) await handOver(flow, to);
 		if (where === "past" || to.rests) {
 			if (step) throw new Stopped();
 			return;
@@ -542,9 +567,13 @@ async function kept(page, rest) {
 		clock: kept.clock - Date.now()
 	};
 }
-async function handOver(flow, did) {
-	const { page, rest, from, again } = flow;
-	if (did?.length) {
+async function handOver(flow, { notes, did }) {
+	const fork = notes && flow.forks.find((fork) => fork.notes.some((note) => notes.includes(note)));
+	if (fork) {
+		flow.forking = true;
+		await fork.body(flow.given);
+	} else if (did?.length) {
+		const { page, rest } = flow;
 		await taking.exit(async () => {
 			for (const one of did) {
 				if (!await doAgain(page, one).then(() => true, () => false)) break;
@@ -554,6 +583,7 @@ async function handOver(flow, did) {
 		flow.handed = await kept(page, rest);
 		return;
 	}
+	const { page, rest, from, again } = flow;
 	flow.handed = from && again.length && holds(flow) ? {
 		...from,
 		again
@@ -571,6 +601,7 @@ const pathTo = (target) => target.evaluate((element) => {
 const playwrightStep = test$1.step;
 const step = Object.assign(async (title, body, options) => {
 	const taken = taking.getStore();
+	if (taken?.forking) return body(void 0);
 	if (taken) {
 		const own = !taken.depth;
 		if (own) Object.assign(taken, {
@@ -597,6 +628,10 @@ const step = Object.assign(async (title, body, options) => {
 			step: title,
 			inStep: 0
 		});
+		flow.forked?.steps.push({
+			title,
+			at: seconds(Date.now() - (flow.events[0]?.timestamp ?? Date.now()))
+		});
 		flow.depth++;
 		let done;
 		try {
@@ -620,7 +655,7 @@ const step = Object.assign(async (title, body, options) => {
 				caret: "hide"
 			}));
 		});
-		if (run?.walk?.step === title && run.walk.actions === void 0 && !flow.walked) await walkOn(flow, run.walk);
+		if (run?.fork?.step === title && run.fork.actions === void 0 && !flow.forked) await forkOn(flow, run.fork);
 		return done;
 	}, options);
 }, playwrightStep);
@@ -637,8 +672,10 @@ const outsideIn = (details) => {
 };
 const keeping = Object.assign((title, ...rest) => {
 	const scopes = [...around];
+	const forks = collectingForks;
 	collecting?.set(title, {
 		body: rest.at(-1),
+		forks,
 		outside: (rest.length > 1 ? outsideIn(rest[0]) : void 0) ?? scopes.findLast((scope) => scope.outside)?.outside,
 		get use() {
 			return Object.assign({}, ...scopes.map((scope) => scope.use));
@@ -660,7 +697,17 @@ const keeping = Object.assign((title, ...rest) => {
 	},
 	extend: () => keeping
 });
-const test = globalThis[ALONGSIDE] ? keeping : withSteps(recorded);
+const forks = [];
+const fork = (name, { notes }, body) => void forks.push({
+	name,
+	notes: notes.map(String),
+	body
+});
+const test = globalThis[ALONGSIDE] ? Object.assign(keeping, { fork: (name, { notes }, body) => void collectingForks.push({
+	name,
+	notes: notes.map(String),
+	body
+}) }) : Object.assign(withSteps(recorded), { fork });
 const actions = [
 	"click",
 	"dblclick",
@@ -703,6 +750,20 @@ function pace(page) {
 			return result;
 		};
 	}
+	const mouse = Object.getPrototypeOf(page.mouse);
+	const wheel = mouse.wheel;
+	mouse.wheel = async function(deltaX, deltaY) {
+		if (!pointer) return wheel.call(this, deltaX, deltaY);
+		const moves = Math.max(10, Math.min(36, Math.round(Math.hypot(deltaX, deltaY) / 25)));
+		let done = 0;
+		for (let i = 1; i <= moves; i++) {
+			await wheel.call(this, deltaX * (ease(i / moves) - done), deltaY * (ease(i / moves) - done));
+			done = ease(i / moves);
+			await pointer.page.waitForTimeout(FRAME);
+		}
+		await pointer.page.waitForTimeout(650);
+		await glimpse();
+	};
 	const keyboard = Object.getPrototypeOf(page.keyboard);
 	const focused = async (page) => {
 		const on = page.locator(":focus").first();
@@ -721,7 +782,7 @@ function pace(page) {
 }
 async function acted(does, target, act, given) {
 	const taken = taking.getStore();
-	const keeping = taken?.depth ? taken : void 0;
+	const keeping = taken?.depth || taken?.forking ? taken : void 0;
 	let on, address;
 	if (keeping) {
 		if (!holds(keeping)) Object.assign(keeping, {
@@ -739,10 +800,10 @@ async function acted(does, target, act, given) {
 		await dialog;
 	});
 	underway?.actions.push(Date.now());
-	const walk = run?.walk;
-	if (walk && underway?.depth && !underway.walked && walk.step === underway.step && walk.actions === ++underway.inStep) {
+	const fork = run?.fork;
+	if (fork && underway?.depth && !underway.forked && fork.step === underway.step && fork.actions === ++underway.inStep) {
 		await underway.page.waitForTimeout(650);
-		await walkOn(underway, walk);
+		await forkOn(underway, fork);
 	}
 	if (keeping) {
 		await keeping.page.waitForTimeout(SAVING);
@@ -757,7 +818,7 @@ async function acted(does, target, act, given) {
 			again: []
 		});
 	}
-	if (keeping) await reached(keeping, keeping.step, ++keeping.actions);
+	if (keeping && !keeping.forking) await reached(keeping, keeping.step, ++keeping.actions);
 	return result;
 }
 async function follow(flow, target) {
@@ -775,56 +836,32 @@ const doneOn = (target) => target.ariaSnapshot({ timeout: 1e3 }).then((snapshot)
 	} : void 0;
 }, () => void 0);
 function alike(one, other) {
-	if (one.role !== other.role) return false;
-	const words = (name) => name.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean);
-	const [few, many] = [words(one.name), words(other.name)].sort((a, b) => a.length - b.length);
-	return !few.length || few.filter((word) => many.includes(word)).length * 2 >= few.length;
+	return one.role === other.role && sameWords(one.name, other.name);
 }
-async function walkOn(flow, walk) {
+async function forkOn(flow, run) {
 	await flow.rest();
 	const since = () => seconds(Date.now() - (flow.events[0]?.timestamp ?? Date.now()));
-	const walked = flow.walked = {
+	const written = forks.find((fork) => fork.notes.some((note) => run.notes.includes(note)));
+	const ran = flow.forked = {
 		from: since(),
-		done: [],
-		found: []
+		steps: [],
+		...written && { fork: written.name }
 	};
-	const look = async () => {
-		for (const [i, { after, css }] of walk.look.entries()) {
-			if (after !== walked.done.length) continue;
-			walked.found[i] = css ? await flow.page.evaluate((css) => {
-				const on = document.querySelector(css);
-				const node = on ? window.rrwebRecord.record.mirror.getId(on) : -1;
-				return node > 0 ? node : null;
-			}, css).catch(() => null) : null;
-			writeFileSync(join(run.folder, `look-${i}.png`), await flow.page.screenshot({
-				animations: "disabled",
-				caret: "hide"
-			}));
-		}
-	};
-	await look();
-	for (const did of walk.did) {
+	if (written) {
+		const depth = flow.depth;
+		flow.depth = 0;
 		try {
-			await doAgain(flow.page, did);
-		} catch {
-			walked.stopped = did.what || did.on;
-			break;
+			await written.body(flow.given);
+		} catch (error) {
+			ran.failed = {
+				...ran.steps.length && { at: ran.steps.at(-1).title },
+				why: firstLine(String(error?.message ?? error))
+			};
+		} finally {
+			flow.depth = depth;
 		}
-		await flow.rest();
-		walked.done.push(since());
-		await unhovered(flow.page, async () => {
-			const { screen, things, items } = await readPage(flow.page);
-			flow.readings.push({
-				step: "In the app",
-				at: since(),
-				screen,
-				things,
-				items
-			});
-		});
-		await look();
 	}
-	test$1.info().skip(true, "Walked as far as the person's steps go");
+	test$1.info().skip(true, "Ran as far as the note's fork");
 }
 async function doAgain(page, { does, on, with: given }) {
 	const target = page.locator(on).first();
@@ -843,7 +880,7 @@ async function doAgain(page, { does, on, with: given }) {
 }
 async function glimpse() {
 	const flow = underway;
-	if (!pointer || !flow || run?.walk) return;
+	if (!pointer || !flow || run?.fork && !flow.forked) return;
 	const at = seconds(Date.now() - (flow.events[0]?.timestamp ?? Date.now()));
 	const read = await readPage(flow.page).catch(() => void 0);
 	if (read) flow.glimpses.push({

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

@@ -1,4 +1,6 @@
 import { type App } from "./repo.js";
-export declare function keepRunning(app: App, root: string): Promise<number | undefined>;
+export declare function keepRunning(app: App, root: string, { ready }?: {
+    ready?: boolean | undefined;
+}): Promise<number | undefined>;
 export declare function stopApp(url: string): Promise<void>;
 export declare const serves: (url: string) => Promise<boolean>;

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

@@ -7,6 +7,10 @@ export type Found = {
     alike?: Element[];
     box?: Box;
     pieces: string[];
+    reworded?: string;
+    gone?: true;
+    offScreen?: true;
+    top?: number;
 };
 export declare function changesAt(then: Reading, now: Reading, unsteady?: Set<string>, shown?: Shown): Found[];
 type Shown = {

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

@@ -0,0 +1,6 @@
+export type Command = {
+    by: number;
+    boot?: string | number;
+};
+export declare const thisCommand: () => Command;
+export declare const stillAt: (command: Command) => boolean;

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

@@ -1,3 +1,4 @@
+import type { Glimpse, Reading } from "../../page/src/index.js";
 import { type Did, type Flow } from "../../review/src/index.js";
 import { type Failed, type Written } from "./reporter.js";
 import { type App, type Repo } from "./repo.js";
@@ -14,7 +15,7 @@ export type Run = {
     before: boolean;
     taken: string[];
     started: string;
-    walk?: Walk;
+    fork?: ForkRun;
     doneInRound?: Record<string, DoneOn>;
 };
 export type On = {
@@ -22,29 +23,32 @@ export type On = {
     name: string;
 };
 export type DoneOn = Record<string, (On | null)[]>;
-export type Walk = {
+export type ForkRun = {
     flow: string;
     step: string;
     actions?: number;
-    did: Did[];
-    look: {
-        after: number;
-        css?: string;
-    }[];
+    notes: string[];
 };
-export type Walked = {
+export type ForkRan = {
     from: number;
-    done: number[];
-    found: (number | null)[];
-    stopped?: string;
+    fork?: string;
+    steps: {
+        title: string;
+        at: number;
+    }[];
+    failed?: {
+        at?: string;
+        why: string;
+    };
 };
-export declare const WALKED = "walked.json";
+export declare const FORK_RAN = "fork.json";
 export type To = {
     flow: string;
     step?: string;
     actions?: number;
     rests?: boolean;
     did?: Did[];
+    notes?: string[];
 };
 export type Handed = {
     url: string;
@@ -110,17 +114,18 @@ export type Ran = {
     failed: Failed[];
     written: Record<string, Written>;
 };
-export type WalkedRun = Walked & {
+export type ForkRecorded = ForkRan & {
     events: {
         timestamp: number;
     }[];
-    readings: unknown[];
+    readings: Reading[];
+    glimpses: Glimpse[];
     assets: Record<string, string>;
     files: {
         name: string;
         bytes: Buffer;
     }[];
-    pictures: (Buffer | undefined)[];
+    picture?: Buffer;
 };
-export declare function walkFork(repo: Repo, id: string, walk: Walk): Promise<WalkedRun | undefined>;
+export declare function runFork(repo: Repo, id: string, fork: ForkRun): Promise<ForkRecorded | undefined>;
 export declare const failedAt: ({ flow, at, why }: Failed) => string;

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

@@ -14,6 +14,7 @@ export declare function repo(root?: string): {
     round: (review: string, round: number) => string;
     ranOnBefore: (review: string) => string;
     setAside: string;
+    turn: string;
     appFile: string;
     setup: string;
     borrowed: string;

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

@@ -8,6 +8,13 @@ export declare const tablet: Screen;
 export declare const expect: import("@playwright/test").Expect<{}>;
 export declare const onReviewDay: (started: string, now?: number) => Date;
 export type HandTo = (person: string, screen?: Screen) => Promise<Page>;
+declare const recorded: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
+    person: string | undefined;
+    rest: () => Promise<void>;
+    setup: Record<string, any>;
+    handTo: HandTo;
+    recorder: void;
+}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
 export declare function pageFor(browser: Browser, baseURL: string, screen: Screen, use?: BrowserContextOptions): Promise<{
     context: BrowserContext;
     page: Page;
@@ -31,6 +38,7 @@ export type Kept = {
     use: BrowserContextOptions & {
         person?: string;
     };
+    forks: Forked[];
 };
 export declare function flowsIn(file: string, written: number): Promise<Map<string, Kept>>;
 export type Arrived = (step: string | undefined, actions: number | undefined, worked: number) => void;
@@ -42,15 +50,20 @@ export declare function runAlongside(page: Page, { request, baseURL, started, se
     borrowed: string;
     arrived?: Arrived;
     person?: string;
-}, body: Body, orders: Orders): Promise<{
+}, body: Body, orders: Orders, forks?: Forked[]): Promise<{
     handed?: Handed;
     stopped?: Pick<Failed, "at" | "why">;
     made?: Made;
 }>;
-export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
-    person: string | undefined;
-    rest: () => Promise<void>;
-    setup: Record<string, any>;
-    handTo: HandTo;
-    recorder: void;
-}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+type Forked = {
+    name: string;
+    notes: string[];
+    body: Body;
+};
+declare const fork: (name: string, { notes }: {
+    notes: string[];
+}, body: Body) => undefined;
+export declare const test: typeof recorded & {
+    fork: typeof fork;
+};
+export {};

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

@@ -13,3 +13,8 @@ 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;
+export declare function sameWords(one: string, other: string): boolean;
+export declare function firstShown(element: Element, seen: Glimpse[]): {
+    at: number;
+    element: Element;
+} | undefined;

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

@@ -2,3 +2,4 @@ export * from "./reading.js";
 export * from "./names.js";
 export * from "./differences.js";
 export * from "./found.js";
+export * from "./scheme.js";

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

@@ -13,4 +13,5 @@ export declare const sentence: (words: string) => string;
 export declare const wayOf: (across: number, down: number) => string;
 export declare function together(all: Thing[], name?: (thing: Thing) => string): string;
 export declare function rewordedWords(a: Thing, b: Thing): string;
+export declare function rewordedPart(a: string, b: string): string | undefined;
 export declare function lookWords(a: Thing, b: Thing): string;

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

@@ -0,0 +1,6 @@
+export type Answered = {
+    dark: boolean;
+    still: boolean;
+};
+export declare function asRecorded(text: string, recorded: Answered): string;
+export declare function answerAs(view: Window & typeof globalThis, recorded: Answered): void;