@ralphralphai/playwright 0.2.0 → 1.2.0

package/dist/index.mjs

@@ -1,554 +1,6 @@
+import { c as MANIFEST_ATTACHMENT, f as loadConfig, i as prepareArtifactUpload, m as resolveMode, p as loadConfigSync, r as createRawGraphBundle, s as uploadRawGraph, u as Recorder } from "./upload-DPYMUP9Y.mjs";
 import path from "node:path";
 import { expect, mergeTests, test as test$1 } from "@playwright/test";
-import { readFileSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import configPackage from "@ralphralphai/config/package.json" with { type: "json" };
-import { WebRalphConfigSchema } from "@ralphralphai/config/zod";
-import { parse, printParseErrorCode } from "jsonc-parser";
-import { randomUUID } from "node:crypto";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import playwrightPackage from "@playwright/test/package.json" with { type: "json" };
-import { promisify } from "node:util";
-import { gzip } from "node:zlib";
-import { pack } from "tar-stream";
-//#region src/config.ts
-function resolveMode(options) {
-	const mode = options.mode ?? process.env["RALPH_MODE"] ?? (process.env["RALPH_UPLOAD_KEY"] ? "upload" : "off");
-	if (mode === "off" || mode === "local" || mode === "upload") return mode;
-	throw new Error("RALPH_MODE must be off, local, or upload.");
-}
-async function loadConfig(options, root) {
-	const file = configFile(options, root);
-	return snapshot(options.config ?? parseConfig(await readFile(file, "utf8")));
-}
-function loadConfigSync(options, root) {
-	const file = configFile(options, root);
-	return snapshot(options.config ?? parseConfig(readFileSync(file, "utf8")));
-}
-function configFile(options, root) {
-	if (options.config && options.configPath) throw new Error("Provide either ralphOptions.config or configPath, not both.");
-	return path.resolve(root, options.configPath ?? "ralph.jsonc");
-}
-function parseConfig(text) {
-	const errors = [];
-	const value = parse(text, errors, { allowTrailingComma: true });
-	if (errors.length) throw new Error("Invalid Ralph config: " + errors.map((error) => printParseErrorCode(error.error) + " at " + error.offset).join(", "));
-	return value;
-}
-function snapshot(value) {
-	WebRalphConfigSchema.parse(value);
-	return {
-		config: JSON.parse(JSON.stringify(value)),
-		packageVersion: configPackage.version
-	};
-}
-//#endregion
-//#region package.json
-var version = "0.2.0";
-//#endregion
-//#region src/image.ts
-/**
-* Matches the crawler's full-page screenshots: lossless measured larger than this
-* on real sites, which are mostly photographic content.
-*/
-const WEBP_QUALITY = 80;
-async function takeScreenshot(page, deadline) {
-	const options = {
-		fullPage: true,
-		scale: "css"
-	};
-	const webp = await page.screenshot({
-		...options,
-		type: "webp",
-		quality: WEBP_QUALITY,
-		timeout: Math.max(1, deadline - Date.now())
-	});
-	if (webp.length > 0) return {
-		bytes: webp,
-		contentType: "image/webp",
-		...webpSize(webp)
-	};
-	const png = await page.screenshot({
-		...options,
-		type: "png",
-		timeout: Math.max(1, deadline - Date.now())
-	});
-	return {
-		bytes: png,
-		contentType: "image/png",
-		width: png.readUInt32BE(16),
-		height: png.readUInt32BE(20)
-	};
-}
-function imageExtension(contentType) {
-	return contentType === "image/png" ? ".png" : ".webp";
-}
-function webpSize(bytes) {
-	if (bytes.toString("ascii", 0, 4) !== "RIFF" || bytes.toString("ascii", 8, 12) !== "WEBP") throw new Error("The screenshot is not a WebP image.");
-	const chunk = bytes.toString("ascii", 12, 16);
-	if (chunk === "VP8X") return {
-		width: 1 + bytes.readUIntLE(24, 3),
-		height: 1 + bytes.readUIntLE(27, 3)
-	};
-	if (chunk === "VP8 ") return {
-		width: bytes.readUInt16LE(26) & 16383,
-		height: bytes.readUInt16LE(28) & 16383
-	};
-	if (chunk === "VP8L") {
-		const bits = bytes.readUInt32LE(21);
-		return {
-			width: 1 + (bits & 16383),
-			height: 1 + (bits >> 14 & 16383)
-		};
-	}
-	throw new Error("Unsupported WebP chunk: " + chunk);
-}
-//#endregion
-//#region src/layout.ts
-function readLayout(page) {
-	return page.locator("[data-track-id]").filter({ visible: true }).evaluateAll((elements) => ({
-		viewport: {
-			width: window.innerWidth,
-			height: window.innerHeight
-		},
-		document: {
-			width: Math.max(document.documentElement.scrollWidth, document.documentElement.clientWidth, document.body?.scrollWidth ?? 0),
-			height: Math.max(document.documentElement.scrollHeight, document.documentElement.clientHeight, document.body?.scrollHeight ?? 0)
-		},
-		scroll: {
-			x: window.scrollX,
-			y: window.scrollY
-		},
-		devicePixelRatio: window.devicePixelRatio,
-		trackedElements: elements.flatMap((element) => {
-			const trackId = element.getAttribute("data-track-id");
-			const rect = element.getBoundingClientRect();
-			if (!trackId || rect.width <= 0 || rect.height <= 0 || rect.right <= 0 || rect.left >= window.innerWidth) return [];
-			return [{
-				trackId,
-				x: rect.x + window.scrollX,
-				y: rect.y + window.scrollY,
-				width: rect.width,
-				height: rect.height
-			}];
-		})
-	}));
-}
-//#endregion
-//#region src/upload.ts
-function resolveUploadOptions(options) {
-	const uploadKey = process.env["RALPH_UPLOAD_KEY"];
-	const apiUrl = options.apiUrl ?? process.env["RALPH_API_URL"];
-	const appId = options.appId ?? process.env["RALPH_APP_ID"];
-	if (!uploadKey || !apiUrl || !appId) throw new Error("Ralph upload requires RALPH_UPLOAD_KEY, RALPH_API_URL (or ralphOptions.apiUrl), and RALPH_APP_ID (or ralphOptions.appId).");
-	return {
-		uploadKey,
-		apiUrl,
-		appId,
-		timeoutMs: options.uploadTimeoutMs
-	};
-}
-const RAW_GRAPH_BUNDLE_INDEX = "raw_graph.json";
-const RAW_GRAPH_BUNDLE_IMAGE_DIR = "assets/images";
-/**
-* Packs the manifest and screenshots into a gzipped tar archive:
-*
-*   raw_graph.json               { manifest, screenshots: [{ nodeId, path }] }
-*   assets/images/<id>.webp    raw screenshot bytes (.png when too large for WebP)
-*/
-async function createRawGraphBundle(manifest, screenshots) {
-	if (Buffer.byteLength(JSON.stringify(manifest)) > 2097152 || screenshots.length > 500 || screenshots.reduce((total, screenshot) => total + screenshot.bytes.byteLength, 0) > 67108864) throw new Error("Ralph raw graph exceeds upload limits.");
-	const images = screenshots.map(({ nodeId, contentType, bytes }) => {
-		if (!/^[A-Za-z0-9-]{1,64}$/.test(nodeId)) throw new Error(`Ralph node id is not path-safe: ${nodeId}`);
-		return {
-			nodeId,
-			path: `${RAW_GRAPH_BUNDLE_IMAGE_DIR}/${nodeId}${imageExtension(contentType)}`,
-			bytes
-		};
-	});
-	const index = {
-		manifest,
-		screenshots: images.map(({ nodeId, path }) => ({
-			nodeId,
-			path
-		}))
-	};
-	const attrs = {
-		mtime: /* @__PURE__ */ new Date(0),
-		uid: 0,
-		gid: 0
-	};
-	const tar = pack();
-	tar.entry({
-		name: RAW_GRAPH_BUNDLE_INDEX,
-		...attrs
-	}, JSON.stringify(index));
-	for (const { path, bytes } of images) tar.entry({
-		name: path,
-		...attrs
-	}, Buffer.from(bytes));
-	tar.finalize();
-	const chunks = [];
-	for await (const chunk of tar) chunks.push(chunk);
-	const compressed = await promisify(gzip)(Buffer.concat(chunks));
-	if (compressed.byteLength > 67108864) throw new Error("Ralph compressed raw graph bundle exceeds upload limits.");
-	return compressed;
-}
-function isLoopback(url) {
-	return url.hostname === "localhost" || url.hostname === "[::1]" || /^127(\.\d{1,3}){3}$/.test(url.hostname);
-}
-async function uploadRawGraph(manifest, screenshots, options) {
-	if (!/^[A-Za-z0-9_-]{1,64}$/.test(options.appId)) throw new Error(`Ralph app id is not valid: ${options.appId}`);
-	const url = new URL(`/api/upload/playwright/apps/${options.appId}/attempts`, options.apiUrl);
-	if (!(url.protocol === "https:" || url.protocol === "http:" && isLoopback(url)) || !options.uploadKey) throw new Error("Ralph upload requires an HTTPS API URL (HTTP only for loopback hosts) and an upload key.");
-	const timeoutMs = options.timeoutMs ?? 3e4;
-	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("Ralph uploadTimeoutMs must be positive and finite.");
-	const blob = new Blob([new Uint8Array(await createRawGraphBundle(manifest, screenshots))], { type: "application/gzip" });
-	const response = await fetch(url, {
-		method: "POST",
-		headers: { Authorization: `Bearer ${options.uploadKey}` },
-		body: blob,
-		redirect: "error",
-		signal: AbortSignal.timeout(timeoutMs)
-	});
-	if (!response.ok) throw new Error(`Ralph upload failed (HTTP ${response.status}). Local Ralph artifacts are retained for retry.`);
-	const receipt = await response.json();
-	if (receipt.result !== "ok" || receipt.status !== "received" || receipt.attemptId !== manifest.attemptId || typeof receipt.resultId !== "string" || typeof receipt.replayed !== "boolean") throw new Error("Ralph server returned an invalid upload receipt.");
-	return receipt;
-}
-//#endregion
-//#region src/recorder.ts
-const MANIFEST_ATTACHMENT = "ralph-raw-graph";
-const DEFAULT_SETTLE_MS = 150;
-const DEFAULT_RECORD_TIMEOUT_MS = 5e3;
-/** Where the raw graph and screenshots are written, inside Playwright's per-test output directory. */
-const OUTPUT_DIR = "ralph";
-var Recorder = class {
-	options;
-	config;
-	testInfo;
-	upload;
-	/**
-	* Identifies this run of the test. A retry gets a new recorder, and so a new
-	* id, which is what lets the server tell retries apart and dedupe re-uploads.
-	*/
-	attemptId = randomUUID();
-	startedAt = (/* @__PURE__ */ new Date()).toISOString();
-	/** How long to wait after a navigation's DOM loads before recording. */
-	settleMs;
-	/**
-	* The budget for recording one node, from settling through the screenshot.
-	* Past it, the node is recorded as failed.
-	*/
-	recordTimeoutMs;
-	/**
-	* Every context being watched. `onPage` is kept so `stopContext` can remove
-	* the exact listener `observe` added. The id is stored in the manifest's
-	* `pages[].contextId`.
-	*/
-	contexts = /* @__PURE__ */ new Map();
-	/**
-	* Every tab seen in a watched context, including closed ones, so their
-	* nodes and opener links still reach the manifest.
-	*/
-	pages = /* @__PURE__ */ new Map();
-	/**
-	* Each node's outcome, in completion order. Nodes in one tab complete
-	* in sequence, but tabs interleave; `finish` sorts them.
-	*/
-	nodes = [];
-	/**
-	* When each node was requested, keyed by node id, for linking a
-	* popup's first node to its opener's latest. Numbers, so they compare
-	* without parsing each node's `requestedAt` string.
-	*/
-	requestedAtMs = /* @__PURE__ */ new Map();
-	/** Set by `finish`, after which `observe` throws. */
-	closed = false;
-	constructor(options, config, testInfo, upload) {
-		this.options = options;
-		this.config = config;
-		this.testInfo = testInfo;
-		this.upload = upload;
-		this.settleMs = options.settleMs ?? DEFAULT_SETTLE_MS;
-		this.recordTimeoutMs = options.recordTimeoutMs ?? DEFAULT_RECORD_TIMEOUT_MS;
-		if (!(Number.isFinite(this.settleMs) && this.settleMs >= 0 && Number.isFinite(this.recordTimeoutMs) && this.recordTimeoutMs > this.settleMs)) throw new Error("Ralph recordTimeoutMs must be finite and greater than settleMs, which must be non-negative.");
-	}
-	/** Starts recording URL changes in every current and future tab of `context`. */
-	observe(context) {
-		if (this.closed) throw new Error("The Ralph recorder has finished.");
-		if (this.contexts.has(context)) return;
-		const id = "context-" + this.contexts.size;
-		const onPage = (page) => this.watchPage(page, id);
-		this.contexts.set(context, {
-			id,
-			onPage
-		});
-		context.on("page", onPage);
-		for (const page of context.pages()) onPage(page);
-	}
-	/** Records the page as it is now, e.g. an open dialog at the same URL. */
-	async recordNode(page, options = {}) {
-		this.observe(page.context());
-		const state = this.pages.get(page);
-		if (!state) throw new Error("Cannot record a closed browser page.");
-		await this.enqueue(state, "explicit", options);
-	}
-	/** Waits for every queued recording to finish. */
-	async flush() {
-		await Promise.all([...this.pages.values()].map((state) => state.tail));
-	}
-	/** Stops watching `context` and waits for its queued recordings. */
-	async stopContext(context) {
-		const entry = this.contexts.get(context);
-		if (entry) context.off("page", entry.onPage);
-		const states = [...this.pages.values()].filter((state) => state.page.context() === context);
-		for (const state of states) state.page.off("framenavigated", state.onNavigation);
-		await Promise.all(states.map((state) => state.tail));
-	}
-	/**
-	* Stops recording, then writes the manifest, uploads it if configured, and
-	* fails a passing test whose nodes failed to record.
-	*/
-	async finish() {
-		this.closed = true;
-		await Promise.all([...this.contexts.keys()].map((context) => this.stopContext(context)));
-		await Promise.all([...this.pages.values()].map((state) => state.opener));
-		const nodes = this.nodes.sort((a, b) => a.pageId.localeCompare(b.pageId) || a.sequence - b.sequence);
-		linkPreviousNodes(nodes, (pageId) => this.pageInfo(pageId)?.openerPageId, (nodeId) => this.requestedAtMs.get(nodeId) ?? 0);
-		const failures = nodes.filter((item) => item.status === "failed");
-		const manifest = this.buildManifest(nodes, failures.length);
-		await this.writeManifest(manifest);
-		if (this.upload) await this.uploadManifest(manifest, this.upload);
-		if (failures.length && this.testInfo.status === "passed") throw new Error("Ralph could not record " + failures.length + " page state(s). See the ralph-raw-graph attachment.");
-	}
-	watchPage(page, contextId) {
-		if (this.pages.has(page)) return;
-		const state = {
-			page,
-			info: {
-				pageId: "page-" + this.pages.size,
-				contextId,
-				browserName: page.context().browser()?.browserType().name()
-			},
-			lastUrl: "",
-			generation: 0,
-			sequence: 0,
-			tail: Promise.resolve(),
-			opener: Promise.resolve(),
-			onNavigation: (frame) => {
-				if (frame === page.mainFrame()) this.urlChanged(state);
-			}
-		};
-		this.pages.set(page, state);
-		state.opener = page.opener().then((opener) => {
-			if (opener) state.info.openerPageId = this.pages.get(opener)?.info.pageId;
-		}).catch(() => void 0);
-		page.on("framenavigated", state.onNavigation);
-		this.urlChanged(state);
-	}
-	urlChanged(state) {
-		state.generation++;
-		const url = state.page.url();
-		if (url === state.lastUrl) return;
-		state.lastUrl = url;
-		if (isHttpUrl(url)) this.enqueue(state, "url-change", {}).catch(() => void 0);
-	}
-	/** Queues a recording behind the tab's earlier ones. */
-	enqueue(state, trigger, options) {
-		const actualUrl = state.page.url();
-		const url = options.url === void 0 ? actualUrl : new URL(options.url, actualUrl).href;
-		if (!isHttpUrl(actualUrl) || !isHttpUrl(url)) throw new Error("Ralph recordings require HTTP or HTTPS page and recorded URLs.");
-		const request = {
-			nodeId: randomUUID(),
-			pageId: state.info.pageId,
-			sequence: state.sequence++,
-			requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			actualUrl,
-			url,
-			trigger,
-			...options.state === void 0 ? {} : { state: options.state }
-		};
-		this.requestedAtMs.set(request.nodeId, Date.now());
-		const generation = state.generation;
-		const task = state.tail.then(() => this.record(state, generation, request));
-		state.tail = task.catch(() => void 0);
-		return task;
-	}
-	/**
-	* Records one node and its outcome. Fails if the tab navigates or
-	* closes before it finishes, or if it runs past the record timeout.
-	*/
-	async record(state, generation, request) {
-		const { page } = state;
-		const deadline = startDeadline(this.recordTimeoutMs, "Ralph recording timed out.");
-		const { wait } = deadline;
-		const navigatedAway = () => state.generation !== generation || page.url() !== request.actualUrl;
-		const check = () => {
-			deadline.signal.throwIfAborted();
-			if (navigatedAway()) throw new Error("The page navigated before its recording completed.");
-			if (page.isClosed()) throw new Error("The page closed before its recording completed.");
-		};
-		try {
-			check();
-			if (request.trigger === "url-change") await this.waitForPageToSettle(page, deadline, check);
-			check();
-			const before = await wait(readLayout(page));
-			check();
-			const image = await wait(takeScreenshot(page, deadline.endsAt));
-			check();
-			const after = await wait(readLayout(page));
-			check();
-			this.nodes.push({
-				...request,
-				status: "recorded",
-				recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				layout: before,
-				geometryStable: JSON.stringify(before) === JSON.stringify(after),
-				screenshot: await this.saveScreenshot(request.nodeId, image)
-			});
-		} catch (error) {
-			this.nodes.push({
-				...request,
-				status: navigatedAway() ? "superseded" : "failed",
-				reason: error instanceof Error ? error.message : String(error)
-			});
-			if (request.trigger === "explicit") throw error;
-		} finally {
-			deadline.cancel();
-		}
-	}
-	/** After a navigation: the DOM, the settle delay, then the `ready` hook. */
-	async waitForPageToSettle(page, { wait, signal }, check) {
-		await wait(page.waitForLoadState("domcontentloaded", { timeout: this.recordTimeoutMs }));
-		await wait(setTimeout$1(this.settleMs, void 0, { signal }));
-		check();
-		if (this.options.ready) await wait(this.options.ready(page, signal));
-	}
-	/** Writes the image to the test output and attaches it to the report. */
-	async saveScreenshot(nodeId, image) {
-		const path = "ralph/" + nodeId + imageExtension(image.contentType);
-		const attachmentName = "ralph-screenshot-" + nodeId;
-		await mkdir(this.testInfo.outputPath(OUTPUT_DIR), { recursive: true });
-		await writeFile(this.testInfo.outputPath(path), image.bytes);
-		await this.testInfo.attach(attachmentName, {
-			path: this.testInfo.outputPath(path),
-			contentType: image.contentType
-		});
-		return {
-			path,
-			attachmentName,
-			width: image.width,
-			height: image.height,
-			scale: "css",
-			contentType: image.contentType
-		};
-	}
-	pageInfo(pageId) {
-		return [...this.pages.values()].find((state) => state.info.pageId === pageId)?.info;
-	}
-	buildManifest(nodes, failureCount) {
-		const { testInfo } = this;
-		const testPassed = testInfo.status === "passed";
-		return {
-			formatVersion: 1,
-			producer: {
-				name: "@ralphralphai/playwright",
-				version,
-				playwrightVersion: playwrightPackage.version
-			},
-			runId: this.options.runId ?? process.env["RALPH_RUN_ID"],
-			buildId: this.options.buildId ?? process.env["RALPH_BUILD_ID"],
-			attemptId: this.attemptId,
-			test: {
-				id: testInfo.testId,
-				titlePath: testInfo.titlePath,
-				project: testInfo.project.name,
-				retry: testInfo.retry,
-				repeatEachIndex: testInfo.repeatEachIndex,
-				workerIndex: testInfo.workerIndex,
-				parallelIndex: testInfo.parallelIndex,
-				shard: testInfo.config.shard,
-				status: failureCount && testPassed ? "failed" : testInfo.status ?? "unknown",
-				expectedStatus: testInfo.expectedStatus
-			},
-			startedAt: this.startedAt,
-			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			config: this.config,
-			pages: [...this.pages.values()].map((state) => state.info),
-			nodes,
-			complete: testPassed && nodes.length > 0 && nodes.every((item) => item.status === "recorded" && item.geometryStable)
-		};
-	}
-	async writeManifest(manifest) {
-		const file = this.testInfo.outputPath(OUTPUT_DIR, "raw_graph.json");
-		await mkdir(this.testInfo.outputPath(OUTPUT_DIR), { recursive: true });
-		await writeFile(file, JSON.stringify(manifest, null, 2) + "\n");
-		await this.testInfo.attach(MANIFEST_ATTACHMENT, {
-			path: file,
-			contentType: "application/json"
-		});
-	}
-	async uploadManifest(manifest, upload) {
-		const recorded = manifest.nodes.filter((item) => item.status === "recorded");
-		const screenshots = [];
-		for (const { nodeId, screenshot } of recorded) screenshots.push({
-			nodeId,
-			contentType: screenshot.contentType,
-			bytes: await readFile(this.testInfo.outputPath(screenshot.path))
-		});
-		const receipt = await uploadRawGraph(manifest, screenshots, upload);
-		await this.testInfo.attach("ralph-upload-receipt", {
-			body: JSON.stringify(receipt),
-			contentType: "application/json"
-		});
-	}
-};
-function isHttpUrl(url) {
-	return /^https?:/.test(url);
-}
-function startDeadline(timeoutMs, message) {
-	const controller = new AbortController();
-	const { signal } = controller;
-	const timer = setTimeout(() => controller.abort(new Error(message)), timeoutMs);
-	const aborted = new Promise((_, reject) => {
-		signal.addEventListener("abort", () => reject(signal.reason), { once: true });
-	});
-	aborted.catch(() => void 0);
-	return {
-		signal,
-		endsAt: Date.now() + timeoutMs,
-		wait: (promise) => Promise.race([promise, aborted]),
-		cancel: () => clearTimeout(timer)
-	};
-}
-/**
-* Sets `previousNodeId` on each node: the one before it in the same
-* tab, or for a popup's first node, its opener's latest. Superseded nodes
-* are skipped, since their page state was never shown.
-*
-* `nodes` must be sorted by page, then sequence.
-*/
-function linkPreviousNodes(nodes, openerOf, requestedAtMs) {
-	const byPage = /* @__PURE__ */ new Map();
-	for (const item of nodes) byPage.set(item.pageId, [...byPage.get(item.pageId) ?? [], item]);
-	const openerNodeBefore = (item) => {
-		const openerPageId = openerOf(item.pageId);
-		const requestedAt = requestedAtMs(item.nodeId);
-		return byPage.get(openerPageId ?? "")?.filter((candidate) => requestedAtMs(candidate.nodeId) <= requestedAt).at(-1);
-	};
-	const previous = /* @__PURE__ */ new Map();
-	for (const items of byPage.values()) items.forEach((item, index) => {
-		const from = index > 0 ? items[index - 1] : openerNodeBefore(item);
-		if (from) previous.set(item, from);
-	});
-	for (const item of nodes) {
-		let from = previous.get(item);
-		while (from?.status === "superseded") from = previous.get(from);
-		if (from) item.previousNodeId = from.nodeId;
-	}
-}
-//#endregion
 //#region src/screens.ts
 const SCREEN_TAG_PREFIX = "@ralph-screen:";
 function screenLabel(size) {
@@ -610,11 +62,13 @@ const test = test$1.extend({
 		await use();
 	}, { auto: true }],
 	_ralphRecorder: [async ({ ralphOptions, _ralphConfigs, _ralphScreen }, use, testInfo) => {
-		if (!testInfo.tags.includes("@ralph") || resolveMode(ralphOptions) === "off") {
+		const mode = resolveMode(ralphOptions);
+		if (!testInfo.tags.includes("@ralph") || mode === "off") {
 			await use(null);
 			return;
 		}
-		const upload = resolveMode(ralphOptions) === "upload" ? resolveUploadOptions(ralphOptions) : void 0;
+		const reported = process.env["RALPH_PLAYWRIGHT_REPORTER"] || testInfo.config.reporter.some(([name]) => name === "blob");
+		if (mode === "upload" && !reported) throw new Error("Ralph uploads one merged graph per run from its reporter. Add ['@ralphralphai/playwright/reporter'] to `reporter` in playwright.config, or use the blob reporter and merge-reports when sharding.");
 		const root = testInfo.config.configFile ? path.dirname(testInfo.config.configFile) : process.cwd();
 		const key = JSON.stringify({
 			root,
@@ -626,7 +80,7 @@ const test = test$1.extend({
 			pending = loadConfig(ralphOptions, root);
 			_ralphConfigs.set(key, pending);
 		}
-		const recorder = new Recorder(ralphOptions, await pending, testInfo, upload);
+		const recorder = new Recorder(ralphOptions, await pending, testInfo, mode);
 		try {
 			await use(recorder);
 		} finally {
@@ -644,12 +98,20 @@ const test = test$1.extend({
 			recordNode: async () => {
 				checkOptIn();
 			},
-			flush: async () => {},
+			waitForCapture: async () => {},
+			pause: () => {},
+			resume: () => {},
 			observe: () => {
 				checkOptIn();
 			}
 		});
 	},
+	contextOptions: async ({ contextOptions, ralphOptions }, use, testInfo) => {
+		await use(testInfo.tags.includes("@ralph") && resolveMode(ralphOptions) !== "off" && ralphOptions.reduceMotion ? {
+			...contextOptions,
+			reducedMotion: "reduce"
+		} : contextOptions);
+	},
 	context: async ({ context, _ralphRecorder }, use) => {
 		_ralphRecorder?.observe(context);
 		try {
@@ -660,6 +122,6 @@ const test = test$1.extend({
 	}
 });
 //#endregion
-export { MANIFEST_ATTACHMENT, SCREEN_TAG_PREFIX, createRawGraphBundle, expect, mergeTests, ralphProjects, test, uploadRawGraph };
+export { MANIFEST_ATTACHMENT, SCREEN_TAG_PREFIX, createRawGraphBundle, expect, mergeTests, prepareArtifactUpload, ralphProjects, test, uploadRawGraph };
 
 //# sourceMappingURL=index.mjs.map