@ralphralphai/playwright 0.1.0

package/dist/index.cjs

@@ -0,0 +1,708 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _playwright_test = require("@playwright/test");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
+let _ralphralphai_config_package_json = require("@ralphralphai/config/package.json");
+_ralphralphai_config_package_json = __toESM(_ralphralphai_config_package_json, 1);
+let _ralphralphai_config_zod = require("@ralphralphai/config/zod");
+let jsonc_parser = require("jsonc-parser");
+let node_crypto = require("node:crypto");
+let node_timers_promises = require("node:timers/promises");
+let _playwright_test_package_json = require("@playwright/test/package.json");
+_playwright_test_package_json = __toESM(_playwright_test_package_json, 1);
+let node_util = require("node:util");
+let node_zlib = require("node:zlib");
+let tar_stream = require("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 (0, node_fs_promises.readFile)(file, "utf8")));
+}
+function loadConfigSync(options, root) {
+	const file = configFile(options, root);
+	return snapshot(options.config ?? parseConfig((0, node_fs.readFileSync)(file, "utf8")));
+}
+function configFile(options, root) {
+	if (options.config && options.configPath) throw new Error("Provide either ralphOptions.config or configPath, not both.");
+	return node_path.default.resolve(root, options.configPath ?? "ralph.jsonc");
+}
+function parseConfig(text) {
+	const errors = [];
+	const value = (0, jsonc_parser.parse)(text, errors, { allowTrailingComma: true });
+	if (errors.length) throw new Error("Invalid Ralph config: " + errors.map((error) => (0, jsonc_parser.printParseErrorCode)(error.error) + " at " + error.offset).join(", "));
+	return value;
+}
+function snapshot(value) {
+	_ralphralphai_config_zod.WebRalphConfigSchema.parse(value);
+	return {
+		config: JSON.parse(JSON.stringify(value)),
+		packageVersion: _ralphralphai_config_package_json.default.version
+	};
+}
+//#endregion
+//#region package.json
+var version = "0.1.0";
+//#endregion
+//#region src/image.ts
+/**
+* Matches the crawler's full-page captures: 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 CAPTURE_BUNDLE_INDEX = "capture.json";
+const CAPTURE_BUNDLE_IMAGE_DIR = "assets/images";
+/**
+* Packs the manifest and screenshots into a gzipped tar archive:
+*
+*   capture.json               { manifest, screenshots: [{ nodeId, path }] }
+*   assets/images/<id>.webp    raw screenshot bytes (.png when too large for WebP)
+*/
+async function createCaptureBundle(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 capture attempt 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: `${CAPTURE_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 = (0, tar_stream.pack)();
+	tar.entry({
+		name: CAPTURE_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 (0, node_util.promisify)(node_zlib.gzip)(Buffer.concat(chunks));
+	if (compressed.byteLength > 67108864) throw new Error("Ralph compressed capture 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 uploadCapture(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 createCaptureBundle(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 capture artifacts are retained for retry.`);
+	const receipt = await response.json();
+	if (receipt.result !== "ok" || receipt.status !== "received" || receipt.attemptId !== manifest.attemptId || 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-captures";
+const DEFAULT_SETTLE_MS = 150;
+const DEFAULT_CAPTURE_TIMEOUT_MS = 5e3;
+/** Where captures 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 = (0, node_crypto.randomUUID)();
+	startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	/** How long to wait after a navigation's DOM loads before capturing. */
+	settleMs;
+	/**
+	* The budget for one capture, from settling through the screenshot. Past it,
+	* the capture is recorded as failed.
+	*/
+	captureTimeoutMs;
+	/**
+	* 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
+	* captures and opener links still reach the manifest.
+	*/
+	pages = /* @__PURE__ */ new Map();
+	/**
+	* Each capture's outcome, in completion order. Captures in one tab complete
+	* in sequence, but tabs interleave; `finish` sorts them.
+	*/
+	nodes = [];
+	/**
+	* When each capture was requested, keyed by capture id, for linking a
+	* popup's first capture 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.captureTimeoutMs = options.captureTimeoutMs ?? DEFAULT_CAPTURE_TIMEOUT_MS;
+		if (!(Number.isFinite(this.settleMs) && this.settleMs >= 0 && Number.isFinite(this.captureTimeoutMs) && this.captureTimeoutMs > this.settleMs)) throw new Error("Ralph captureTimeoutMs must be finite and greater than settleMs, which must be non-negative.");
+	}
+	/** Starts capturing 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);
+	}
+	/** Captures the page as it is now, e.g. an open dialog at the same URL. */
+	async captureNode(page, options = {}) {
+		this.observe(page.context());
+		const state = this.pages.get(page);
+		if (!state) throw new Error("Cannot capture a closed browser page.");
+		await this.enqueue(state, "explicit", options);
+	}
+	/** Waits for every queued capture to finish. */
+	async flush() {
+		await Promise.all([...this.pages.values()].map((state) => state.tail));
+	}
+	/** Stops watching `context` and waits for its queued captures. */
+	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 captures failed.
+	*/
+	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 capture " + failures.length + " page state(s). See the ralph-captures 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 capture 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 captures require HTTP or HTTPS page and recorded URLs.");
+		const request = {
+			nodeId: (0, node_crypto.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;
+	}
+	/**
+	* Takes one capture and records its outcome. Fails if the tab navigates or
+	* closes before it finishes, or if it runs past the capture timeout.
+	*/
+	async record(state, generation, request) {
+		const { page } = state;
+		const deadline = startDeadline(this.captureTimeoutMs, "Ralph capture 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 capture completed.");
+			if (page.isClosed()) throw new Error("The page closed before its capture 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: "captured",
+				capturedAt: (/* @__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.captureTimeoutMs }));
+		await wait((0, node_timers_promises.setTimeout)(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 (0, node_fs_promises.mkdir)(this.testInfo.outputPath(OUTPUT_DIR), { recursive: true });
+		await (0, node_fs_promises.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: _playwright_test_package_json.default.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 === "captured" && item.geometryStable)
+		};
+	}
+	async writeManifest(manifest) {
+		const file = this.testInfo.outputPath(OUTPUT_DIR, "captures.json");
+		await (0, node_fs_promises.mkdir)(this.testInfo.outputPath(OUTPUT_DIR), { recursive: true });
+		await (0, node_fs_promises.writeFile)(file, JSON.stringify(manifest, null, 2) + "\n");
+		await this.testInfo.attach(MANIFEST_ATTACHMENT, {
+			path: file,
+			contentType: "application/json"
+		});
+	}
+	async uploadManifest(manifest, upload) {
+		const captured = manifest.nodes.filter((item) => item.status === "captured");
+		const screenshots = [];
+		for (const { nodeId, screenshot } of captured) screenshots.push({
+			nodeId,
+			contentType: screenshot.contentType,
+			bytes: await (0, node_fs_promises.readFile)(this.testInfo.outputPath(screenshot.path))
+		});
+		const receipt = await uploadCapture(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 capture, its opener's latest. Superseded captures
+* 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) {
+	return size.width + "x" + size.height;
+}
+/**
+* Expands `base` into one project per `screenSizes` entry of the Ralph config.
+* Each project's viewport is that screen size.
+*/
+function ralphProjects(base = {}, options = {}) {
+	const { screenSizes } = loadConfigSync(options, options.root ?? process.cwd()).config;
+	if (!screenSizes.length) throw new Error("The Ralph config declares no screenSizes.");
+	return screenSizes.map((screenSize) => {
+		const label = screenLabel(screenSize);
+		const ralph = {
+			screenSize,
+			screenSizes
+		};
+		return {
+			...base,
+			name: base.name ? base.name + " " + label : label,
+			use: {
+				...base.use,
+				viewport: {
+					width: screenSize.width,
+					height: screenSize.height
+				}
+			},
+			metadata: {
+				...base.metadata,
+				ralph
+			}
+		};
+	});
+}
+/**
+* Skips a test whose `@ralph-screen:WxH` tags exclude the current project's
+* screen size. Untagged tests run at every size; other projects are untouched.
+*/
+function applyScreenSelection(testInfo) {
+	const selected = testInfo.tags.filter((tag) => tag.startsWith(SCREEN_TAG_PREFIX)).map((tag) => tag.slice(14));
+	const metadata = testInfo.project.metadata.ralph;
+	if (!selected.length || !metadata) return;
+	const known = metadata.screenSizes.map(screenLabel);
+	const unknown = selected.filter((label) => !known.includes(label));
+	if (unknown.length) throw new Error("Unknown Ralph screen size " + unknown.join(", ") + "; the config declares " + known.join(", ") + ".");
+	const current = screenLabel(metadata.screenSize);
+	testInfo.skip(!selected.includes(current), "Not selected for Ralph screen size " + current + ".");
+}
+//#endregion
+//#region src/index.ts
+const test = _playwright_test.test.extend({
+	ralphOptions: [{}, { option: true }],
+	_ralphConfigs: [async ({}, use) => {
+		await use(/* @__PURE__ */ new Map());
+	}, { scope: "worker" }],
+	_ralphScreen: [async ({}, use, testInfo) => {
+		applyScreenSelection(testInfo);
+		await use();
+	}, { auto: true }],
+	_ralphRecorder: [async ({ ralphOptions, _ralphConfigs, _ralphScreen }, use, testInfo) => {
+		if (!testInfo.tags.includes("@ralph") || resolveMode(ralphOptions) === "off") {
+			await use(null);
+			return;
+		}
+		const upload = resolveMode(ralphOptions) === "upload" ? resolveUploadOptions(ralphOptions) : void 0;
+		const root = testInfo.config.configFile ? node_path.default.dirname(testInfo.config.configFile) : process.cwd();
+		const key = JSON.stringify({
+			root,
+			config: ralphOptions.config,
+			configPath: ralphOptions.configPath
+		});
+		let pending = _ralphConfigs.get(key);
+		if (!pending) {
+			pending = loadConfig(ralphOptions, root);
+			_ralphConfigs.set(key, pending);
+		}
+		const recorder = new Recorder(ralphOptions, await pending, testInfo, upload);
+		try {
+			await use(recorder);
+		} finally {
+			await recorder.finish();
+		}
+	}, {
+		auto: true,
+		timeout: 3e4
+	}],
+	ralph: async ({ _ralphRecorder, ralphOptions }, use) => {
+		const checkOptIn = () => {
+			if (resolveMode(ralphOptions) !== "off") throw new Error("Opt this test into Ralph with the @ralph tag.");
+		};
+		await use(_ralphRecorder ?? {
+			captureNode: async () => {
+				checkOptIn();
+			},
+			flush: async () => {},
+			observe: () => {
+				checkOptIn();
+			}
+		});
+	},
+	context: async ({ context, _ralphRecorder }, use) => {
+		_ralphRecorder?.observe(context);
+		try {
+			await use(context);
+		} finally {
+			await _ralphRecorder?.stopContext(context);
+		}
+	}
+});
+//#endregion
+exports.MANIFEST_ATTACHMENT = MANIFEST_ATTACHMENT;
+exports.SCREEN_TAG_PREFIX = SCREEN_TAG_PREFIX;
+exports.createCaptureBundle = createCaptureBundle;
+Object.defineProperty(exports, "expect", {
+	enumerable: true,
+	get: function() {
+		return _playwright_test.expect;
+	}
+});
+Object.defineProperty(exports, "mergeTests", {
+	enumerable: true,
+	get: function() {
+		return _playwright_test.mergeTests;
+	}
+});
+exports.ralphProjects = ralphProjects;
+exports.test = test;
+exports.uploadCapture = uploadCapture;
+
+//# sourceMappingURL=index.cjs.map