playthrough 0.5.1 → 0.6.0

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-S9fOk0za.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-vi0amwSo.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";
@@ -138,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);
@@ -176,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 = {
@@ -191,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));
@@ -214,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()
 			}));
 		}
@@ -387,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 {
@@ -406,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));
@@ -420,6 +438,7 @@ async function runAlongside(page, { request, baseURL, started, setup: appSetup,
 	};
 	const flow = {
 		page,
+		forks,
 		depth: 0,
 		rest: async () => {},
 		actions: 0,
@@ -468,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,
@@ -505,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;
@@ -547,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;
@@ -559,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
@@ -576,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, {
@@ -602,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 {
@@ -625,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);
@@ -642,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));
@@ -665,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",
@@ -740,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, {
@@ -758,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);
@@ -776,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) {
@@ -794,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: []
-	};
-	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"
-			}));
-		}
+		steps: [],
+		...written && { fork: written.name }
 	};
-	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();
@@ -862,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/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/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/review/src/model.d.ts

@@ -61,6 +61,10 @@ export declare const Place: z.ZodObject<{
         }, z.core.$strict>>;
         recording: z.ZodString;
         length: z.ZodNumber;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            at: z.ZodNumber;
+        }, z.core.$strict>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const Step: z.ZodObject<{
@@ -128,6 +132,10 @@ export declare const Change: z.ZodObject<{
             }, z.core.$strict>>;
             recording: z.ZodString;
             length: z.ZodNumber;
+            steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                at: z.ZodNumber;
+            }, z.core.$strict>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     pictureOnly: z.ZodOptional<z.ZodLiteral<true>>;
@@ -179,6 +187,10 @@ export declare const Comparison: z.ZodObject<{
                 }, z.core.$strict>>;
                 recording: z.ZodString;
                 length: z.ZodNumber;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    title: z.ZodString;
+                    at: z.ZodNumber;
+                }, z.core.$strict>>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
         pictureOnly: z.ZodOptional<z.ZodLiteral<true>>;
@@ -233,6 +245,10 @@ export declare const Reply: z.ZodObject<{
             }, z.core.$strict>>;
             recording: z.ZodString;
             length: z.ZodNumber;
+            steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                at: z.ZodNumber;
+            }, z.core.$strict>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     watch: z.ZodOptional<z.ZodString>;
@@ -278,6 +294,10 @@ export declare const Note: z.ZodObject<{
             }, z.core.$strict>>;
             recording: z.ZodString;
             length: z.ZodNumber;
+            steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                at: z.ZodNumber;
+            }, z.core.$strict>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     words: z.ZodString;
@@ -342,6 +362,10 @@ export declare const Round: z.ZodObject<{
                 }, z.core.$strict>>;
                 recording: z.ZodString;
                 length: z.ZodNumber;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    title: z.ZodString;
+                    at: z.ZodNumber;
+                }, z.core.$strict>>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
         watch: z.ZodOptional<z.ZodString>;
@@ -411,6 +435,10 @@ export declare const Send: z.ZodObject<{
                 }, z.core.$strict>>;
                 recording: z.ZodString;
                 length: z.ZodNumber;
+                steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    title: z.ZodString;
+                    at: z.ZodNumber;
+                }, z.core.$strict>>>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
         words: z.ZodString;
@@ -500,6 +528,10 @@ export declare const Review: z.ZodObject<{
                     }, z.core.$strict>>;
                     recording: z.ZodString;
                     length: z.ZodNumber;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        title: z.ZodString;
+                        at: z.ZodNumber;
+                    }, z.core.$strict>>>;
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
             watch: z.ZodOptional<z.ZodString>;
@@ -562,6 +594,10 @@ export declare const Review: z.ZodObject<{
                     }, z.core.$strict>>;
                     recording: z.ZodString;
                     length: z.ZodNumber;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        title: z.ZodString;
+                        at: z.ZodNumber;
+                    }, z.core.$strict>>>;
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
             pictureOnly: z.ZodOptional<z.ZodLiteral<true>>;
@@ -613,6 +649,10 @@ export declare const Review: z.ZodObject<{
                     }, z.core.$strict>>;
                     recording: z.ZodString;
                     length: z.ZodNumber;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        title: z.ZodString;
+                        at: z.ZodNumber;
+                    }, z.core.$strict>>>;
                 }, z.core.$strict>>;
             }, z.core.$strict>>;
             words: z.ZodString;

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

@@ -72,6 +72,10 @@ export declare const toAccountFor: (comparison?: Comparison) => {
             }[];
             recording: string;
             length: number;
+            steps?: {
+                title: string;
+                at: number;
+            }[] | undefined;
         } | undefined;
     }[];
     pictureOnly?: true | undefined;