@ralphralphai/playwright 0.2.0 → 1.2.0

package/dist/upload-DPYMUP9Y.mjs

@@ -0,0 +1,702 @@
+import path from "node:path";
+import { errors } 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 { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGzip } 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 = "1.2.0";
+//#endregion
+//#region src/animations.ts
+/**
+* Waits until no finite CSS animation, CSS transition, or Web Animation is
+* running. Infinite ones (spinners, shimmers) never finish, so they are
+* ignored. Animations driven by `requestAnimationFrame` are invisible here.
+*
+* Stops waiting after `timeoutMs` without failing; the screenshot then jumps
+* whatever is left to its end state.
+*/
+async function waitForAnimations(page, timeoutMs) {
+	try {
+		await page.waitForFunction(() => document.getAnimations().every((animation) => animation.playState !== "running" || animation.playbackRate === 0 || !Number.isFinite(animation.effect?.getComputedTiming().endTime)), void 0, {
+			polling: "raf",
+			timeout: Math.max(1, timeoutMs)
+		});
+	} catch (error) {
+		if (!(error instanceof errors.TimeoutError)) throw error;
+	}
+}
+//#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",
+		animations: "disabled"
+	};
+	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/recorder.ts
+/** The attachment holding a test's `RawGraphFile`, which the reporter merges. */
+const MANIFEST_ATTACHMENT = "ralph-raw-graph";
+/**
+* Set by the reporter in the main process before any worker starts, so the
+* fixtures can refuse to upload without it.
+*/
+const REPORTER_ENV = "RALPH_PLAYWRIGHT_REPORTER";
+/** Prefix of the attachment holding each recorded node's screenshot; the node id follows. */
+const SCREENSHOT_ATTACHMENT_PREFIX = "ralph-screenshot-";
+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;
+	mode;
+	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, with its page listener, kept so
+	* `stopContext` can remove the exact listener `observe` added.
+	*/
+	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;
+	/** Set by `pause`; while set, no new nodes are requested. */
+	paused = false;
+	/** The most recently requested node, the anchor for tabs used while paused. */
+	lastRequestedNodeId;
+	constructor(options, config, testInfo, mode) {
+		this.options = options;
+		this.config = config;
+		this.testInfo = testInfo;
+		this.mode = mode;
+		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 onPage = (page) => this.watchPage(page);
+		this.contexts.set(context, 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.");
+		if (this.paused) return;
+		await this.enqueueCreateNodeRequest(state, "explicit", options);
+	}
+	/**
+	* Stops requesting nodes, automatic or explicit, until `resume`. Recordings
+	* already requested still complete. The next node after `resume` links to
+	* the last one before `pause`, so the skipped steps drop out of the graph.
+	*/
+	pause() {
+		this.paused = true;
+	}
+	/** Undoes `pause`. The current page is not recorded until its URL changes. */
+	resume() {
+		this.paused = false;
+	}
+	/** Waits until every page recording requested so far has finished. */
+	async waitForCapture() {
+		await Promise.all([...this.pages.values()].map((state) => state.tail));
+	}
+	/** Stops watching `context` and waits for its queued recordings. */
+	async stopContext(context) {
+		const onPage = this.contexts.get(context);
+		if (onPage) context.off("page", 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 test's raw graph for the reporter, 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, (pageId) => this.pageState(pageId)?.pauseAnchor);
+		const failures = nodes.filter((item) => item.status === "uncaptured" && item.reason === "error");
+		await this.writeRawGraph(this.buildRawGraph(nodes, failures.length));
+		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) {
+		if (this.pages.has(page)) return;
+		const state = {
+			page,
+			info: {
+				pageId: "page-" + this.pages.size,
+				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) {
+				const openerState = this.pages.get(opener);
+				state.info.openerPageId = openerState?.info.pageId;
+				state.pauseAnchor ??= openerState?.pauseAnchor;
+			}
+		}).catch(() => void 0);
+		page.on("framenavigated", state.onNavigation);
+		this.urlChanged(state);
+	}
+	urlChanged(state) {
+		if (this.paused && state.sequence === 0) state.pauseAnchor ??= this.lastRequestedNodeId;
+		const url = state.page.url();
+		if (url === state.lastUrl) return;
+		state.generation++;
+		state.lastUrl = url;
+		if (!this.paused && isHttpUrl(url)) this.enqueueCreateNodeRequest(state, "url-change", {}).catch(() => void 0);
+	}
+	/** Queues a recording behind the tab's earlier ones. */
+	enqueueCreateNodeRequest(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());
+		this.lastRequestedNodeId = request.nodeId;
+		const generation = state.generation;
+		const task = state.tail.then(() => this.createNode(state, generation, request));
+		state.tail = task.catch(() => void 0);
+		return task;
+	}
+	/**
+	* Creates the requested node: `recorded`, or `uncaptured` if the tab
+	* navigates or closes first, or the record timeout passes.
+	*/
+	async createNode(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);
+			if (this.options.reduceMotion) {
+				check();
+				await wait(waitForAnimations(page, (deadline.endsAt - Date.now()) / 2));
+			}
+			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: "uncaptured",
+				reason: navigatedAway() ? "navigated-away" : "error",
+				message: 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 = SCREENSHOT_ATTACHMENT_PREFIX + nodeId;
+		await mkdir(this.testInfo.outputPath(OUTPUT_DIR), { recursive: true });
+		await writeFile(this.testInfo.outputPath(path), image.bytes);
+		await this.testInfo.attach(attachmentName, {
+			...this.testInfo.config.preserveOutput === "always" ? { path: this.testInfo.outputPath(path) } : { body: image.bytes },
+			contentType: image.contentType
+		});
+		return {
+			path,
+			attachmentName,
+			width: image.width,
+			height: image.height,
+			scale: "css",
+			contentType: image.contentType
+		};
+	}
+	pageState(pageId) {
+		return [...this.pages.values()].find((state) => state.info.pageId === pageId);
+	}
+	pageInfo(pageId) {
+		return this.pageState(pageId)?.info;
+	}
+	buildRawGraph(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"],
+			config: this.config,
+			mode: this.mode,
+			rawGraph: {
+				id: testInfo.testId,
+				titlePath: testInfo.titlePath,
+				project: testInfo.project.name,
+				retry: testInfo.retry,
+				repeatEachIndex: testInfo.repeatEachIndex,
+				workerIndex: testInfo.workerIndex,
+				parallelIndex: testInfo.parallelIndex,
+				status: failureCount && testPassed ? "failed" : testInfo.status ?? "unknown",
+				expectedStatus: testInfo.expectedStatus,
+				startedAt: this.startedAt,
+				finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				pages: [...this.pages.values()].map((state) => state.info),
+				nodes,
+				complete: testPassed && nodes.length > 0 && nodes.every((item) => item.status === "recorded" && item.geometryStable)
+			}
+		};
+	}
+	async writeRawGraph(file) {
+		const path = this.testInfo.outputPath(OUTPUT_DIR, "raw_graph.json");
+		const body = JSON.stringify(file, null, 2) + "\n";
+		await mkdir(this.testInfo.outputPath(OUTPUT_DIR), { recursive: true });
+		await writeFile(path, body);
+		await this.testInfo.attach(MANIFEST_ATTACHMENT, {
+			...this.testInfo.config.preserveOutput === "always" ? { path } : { body },
+			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. Failing both, a tab
+* first used while paused links to the last node before the pause.
+* Uncaptured nodes stay in the chain, as regular nodes in the server's graph.
+*
+* `nodes` must be sorted by page, then sequence.
+*/
+function linkPreviousNodes(nodes, openerOf, requestedAtMs, pauseAnchorOf) {
+	const byPage = /* @__PURE__ */ new Map();
+	const byId = /* @__PURE__ */ new Map();
+	for (const item of nodes) {
+		byPage.set(item.pageId, [...byPage.get(item.pageId) ?? [], item]);
+		byId.set(item.nodeId, 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);
+	};
+	for (const items of byPage.values()) items.forEach((item, index) => {
+		const from = index > 0 ? items[index - 1] : openerNodeBefore(item) ?? byId.get(pauseAnchorOf(item.pageId) ?? "");
+		if (from) item.previousNodeId = from.nodeId;
+	});
+}
+/** Where the uploaded run opens: the server's link, else the Ralph dashboard. */
+function resultLink({ artifactId, resultUrl }) {
+	return resultUrl ?? `https://dash.ralphralph.ai/uploads/${encodeURIComponent(artifactId)}`;
+}
+/** Where the reporter uploads: its options, else the environment, else Ralph's production server. */
+function resolveUploadOptions(options) {
+	const uploadKey = process.env["RALPH_UPLOAD_KEY"];
+	const apiUrl = options.apiUrl || process.env["RALPH_API_URL"] || "https://api.ralphralph.ai";
+	const appId = options.appId ?? process.env["RALPH_APP_ID"];
+	if (!uploadKey) throw new Error(`To upload to Ralph, set RALPH_UPLOAD_KEY. ${CREATE_KEY_HINT}`);
+	if (!appId) throw new Error("To upload to Ralph, set RALPH_APP_ID (or the reporter option appId) to the app the recordings belong to.");
+	return {
+		uploadKey,
+		apiUrl,
+		appId,
+		timeoutMs: options.uploadTimeoutMs
+	};
+}
+const RAW_GRAPH_BUNDLE_INDEX = "raw_graph.json";
+const RAW_GRAPH_BUNDLE_IMAGE_DIR = "assets/images";
+/** Where a node's screenshot sits inside the bundle. */
+function bundleImagePath(nodeId, contentType) {
+	if (!/^[A-Za-z0-9-]{1,64}$/.test(nodeId)) throw new Error(`Ralph node id is not path-safe: ${nodeId}`);
+	return `${RAW_GRAPH_BUNDLE_IMAGE_DIR}/${nodeId}${imageExtension(contentType)}`;
+}
+const TOO_BIG = "This run is too big to upload to Ralph. Record fewer pages or screen sizes, or split the tests across runs.";
+var TooBigError = class extends Error {
+	constructor() {
+		super(TOO_BIG);
+	}
+};
+/**
+* Packs the manifest and screenshots into a gzipped tar archive, produced as it
+* is read so the compressed bundle is never held whole:
+*
+*   raw_graph.json               { manifest, screenshots: [{ nodeId, path }] }
+*   assets/images/<id>.webp    raw screenshot bytes (.png when too large for WebP)
+*
+* Fails with a `TooBigError` once the compressed bytes pass the limit.
+*/
+function rawGraphBundleStream(manifest, screenshots) {
+	if (Buffer.byteLength(JSON.stringify(manifest)) > 16777216 || screenshots.length > 5e3 || screenshots.reduce((total, screenshot) => total + screenshot.bytes.byteLength, 0) > 268435456) throw new TooBigError();
+	const images = screenshots.map(({ nodeId, contentType, bytes }) => ({
+		nodeId,
+		path: bundleImagePath(nodeId, 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();
+	const onEntryError = (error) => tar.destroy(error);
+	tar.entry({
+		name: RAW_GRAPH_BUNDLE_INDEX,
+		...attrs
+	}, JSON.stringify(index)).on("error", onEntryError);
+	for (const { path, bytes } of images) tar.entry({
+		name: path,
+		...attrs
+	}, Buffer.from(bytes)).on("error", onEntryError);
+	tar.finalize();
+	const gzip = createGzip();
+	pipeline(tar, gzip).catch((error) => gzip.destroy(error));
+	return Readable.from((async function* () {
+		let size = 0;
+		for await (const chunk of gzip) {
+			size += chunk.byteLength;
+			if (size > 268435456) throw new TooBigError();
+			yield chunk;
+		}
+	})());
+}
+/** The bundle `uploadRawGraph` streams, whole, for saving or inspecting it. */
+async function createRawGraphBundle(manifest, screenshots) {
+	const chunks = [];
+	for await (const chunk of rawGraphBundleStream(manifest, screenshots)) chunks.push(chunk);
+	return Buffer.concat(chunks);
+}
+function isLoopback(url) {
+	return url.hostname === "localhost" || url.hostname === "[::1]" || /^127(\.\d{1,3}){3}$/.test(url.hostname);
+}
+function checkedApiUrl(options, path) {
+	if (!/^[A-Za-z0-9_-]{1,64}$/.test(options.appId)) throw new Error(`"${options.appId}" isn't a valid Ralph app id. Check RALPH_APP_ID.`);
+	const url = new URL(path, options.apiUrl);
+	if (!(url.protocol === "https:" || url.protocol === "http:" && isLoopback(url))) throw new Error(`RALPH_API_URL must start with https:// (http:// only works for localhost), not ${options.apiUrl}.`);
+	if (!options.uploadKey) throw new Error(`To upload to Ralph, set RALPH_UPLOAD_KEY. ${CREATE_KEY_HINT}`);
+	return url;
+}
+/** Sends one request, turning every way it can fail into a message that says what to fix. */
+async function request(url, init, options, timeoutMs) {
+	let response;
+	try {
+		response = await fetch(url, {
+			...init,
+			method: "POST",
+			headers: {
+				...init.headers,
+				Authorization: `Bearer ${options.uploadKey}`
+			},
+			redirect: "error",
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (error) {
+		if (error instanceof TooBigError || error instanceof Error && error.cause instanceof TooBigError) throw new Error(TOO_BIG, { cause: error });
+		throw new Error(describeRequestFailure(error, url, timeoutMs), { cause: error });
+	}
+	if (!response.ok) throw new Error(describeHttpFailure(response.status, await responseDetail(response), url, options.appId));
+	try {
+		return await response.json();
+	} catch {
+		return {};
+	}
+}
+const unreadableReply = (url) => /* @__PURE__ */ new Error("Upload to Ralph failed. Ralph's reply couldn't be read. Update @ralphralphai/playwright to the latest version and run again." + customServerHint(url));
+const PREPARE_TIMEOUT_MS = 3e4;
+/**
+* Reserves an artifact for the run. Its `resultUrl` works from now on, so the
+* run can be followed while it uploads and while Ralph processes it.
+*/
+async function prepareArtifactUpload(options) {
+	const url = checkedApiUrl(options, "/api/upload/artifact/prepare");
+	const reply = await request(url, {
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({ externalAppId: options.appId })
+	}, options, PREPARE_TIMEOUT_MS);
+	if (reply["result"] !== "ok" || typeof reply["artifactId"] !== "string" || reply["resultUrl"] !== void 0 && typeof reply["resultUrl"] !== "string") throw unreadableReply(url);
+	return {
+		artifactId: reply["artifactId"],
+		resultUrl: reply["resultUrl"]
+	};
+}
+/**
+* Streams the run's bundle to the artifact `manifest.artifactId` names, which
+* `prepareArtifactUpload` has to have reserved. Ralph processes it after this
+* returns; the result page shows when it is ready.
+*/
+async function uploadRawGraph(manifest, screenshots, options) {
+	const url = checkedApiUrl(options, `/api/upload/web/apps/${options.appId}/artifact/${encodeURIComponent(manifest.artifactId)}`);
+	const storage = process.env["RALPH_UPLOAD_STORAGE"] || "gcs";
+	if (storage !== "gcs" && storage !== "local") throw new Error(`RALPH_UPLOAD_STORAGE must be gcs or local, not ${storage}.`);
+	if (storage === "local") url.searchParams.set("storage", "local");
+	const timeoutMs = options.timeoutMs ?? 12e4;
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("uploadTimeoutMs in the Ralph reporter options must be a positive number of milliseconds.");
+	const receipt = await request(url, {
+		headers: { "content-type": "application/gzip" },
+		body: Readable.toWeb(rawGraphBundleStream(manifest, screenshots)),
+		duplex: "half"
+	}, options, timeoutMs);
+	if (receipt["result"] !== "ok" || receipt["status"] !== "queued" || receipt["artifactId"] !== manifest.artifactId || receipt["resultUrl"] !== void 0 && typeof receipt["resultUrl"] !== "string" || typeof receipt["replayed"] !== "boolean") throw unreadableReply(url);
+	return receipt;
+}
+const CREATE_KEY_HINT = "You can create an upload key in your project dashboard on Ralph.";
+const SUPPORT_HINT = "If it keeps failing, contact Ralph support.";
+/** Only users who set their own server need to hear about it. */
+function customServerHint(url) {
+	return url.origin === new URL("https://api.ralphralph.ai").origin ? "" : ` Also check RALPH_API_URL (${url.origin}) is right.`;
+}
+function describeRequestFailure(error, url, timeoutMs) {
+	if (error instanceof Error && error.name === "TimeoutError") return `Upload to Ralph took longer than ${timeoutMs / 1e3}s and was stopped. Check your network, or raise uploadTimeoutMs in the reporter options.`;
+	return `Couldn't connect to Ralph (${error instanceof Error && error.cause instanceof Error ? error.cause.message : error instanceof Error ? error.message : String(error)}). Check that this machine can reach ${url.origin}.` + customServerHint(url);
+}
+function describeHttpFailure(status, detail, url, appId) {
+	let message;
+	if (status === 401) message = `Ralph didn't accept your upload key. Check RALPH_UPLOAD_KEY. ${CREATE_KEY_HINT}`;
+	else if (status === 403) message = `Your upload key can't upload to the app "${appId}". Check RALPH_APP_ID is an app in the same project as the key.`;
+	else if (status === 404) message = `Ralph couldn't find the app "${appId}". Check RALPH_APP_ID.` + customServerHint(url);
+	else if (status === 413) message = "This run is too big to upload. Record fewer pages or screen sizes, or split the tests across runs.";
+	else if (status === 429) message = "Too many uploads right now. Wait a minute and run again.";
+	else if (status >= 500) message = `Something went wrong on Ralph's side. Run again later. ${SUPPORT_HINT}`;
+	else message = `Ralph couldn't accept this upload. Update @ralphralphai/playwright to the latest version and run again. ${SUPPORT_HINT}`;
+	return `Upload to Ralph failed. ${message} (HTTP ${status}${detail ? `: ${detail}` : ""})`;
+}
+/** The server's reason for rejecting the upload, kept short. */
+async function responseDetail(response) {
+	let text;
+	try {
+		text = (await response.text()).trim();
+	} catch {
+		return;
+	}
+	try {
+		const body = JSON.parse(text);
+		const message = body.result ?? body.message ?? body.error;
+		if (typeof message === "string") text = message;
+	} catch {}
+	text = text.replace(/\s+/g, " ");
+	return text.length > 200 ? text.slice(0, 200) + "…" : text || void 0;
+}
+//#endregion
+export { resolveUploadOptions as a, MANIFEST_ATTACHMENT as c, version as d, loadConfig as f, prepareArtifactUpload as i, REPORTER_ENV as l, resolveMode as m, bundleImagePath as n, resultLink as o, loadConfigSync as p, createRawGraphBundle as r, uploadRawGraph as s, RAW_GRAPH_BUNDLE_INDEX as t, Recorder as u };
+
+//# sourceMappingURL=upload-DPYMUP9Y.mjs.map