@gfxlabs/third-eye-cli 3.22.0

package/dist/bin.mjs

@@ -0,0 +1,2084 @@
+#!/usr/bin/env node
+import path, { join, normalize } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import fs from "fs-extra";
+import { execSync } from "node:child_process";
+import { mapLimit, retry } from "async";
+import pixelmatch from "pixelmatch";
+import { compare } from "odiff-bin";
+import { PNG } from "pngjs";
+import * as z$1 from "zod";
+import { z } from "zod";
+import { bundleRequire } from "bundle-require";
+import * as crypto from "node:crypto";
+import { randomUUID } from "node:crypto";
+import { PostHog } from "posthog-node";
+import { chromium, firefox, webkit } from "playwright-core";
+import axios, { isAxiosError } from "axios";
+import http from "node:http";
+import handler from "serve-handler";
+import { getPort } from "get-port-please";
+import { createORPCClient } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { execa } from "execa";
+import { XMLParser } from "fast-xml-parser";
+//#region src/log.ts
+const logMemory = [];
+const serializeError = (error) => ({
+	message: error.message,
+	name: error.name,
+	stack: error.stack
+});
+const serializeErrors = (content) => content.map((item) => {
+	if (item instanceof Error) return serializeError(item);
+	return item;
+});
+const renderLog = (entry) => {
+	if (entry.source === "browser" && entry.context === "console") return;
+	if (entry.source === "browser" && entry.context === "network") return;
+	const { log } = console;
+	const logPrefix = [];
+	if (entry.item) logPrefix.push(`[${entry.item.itemIndex + 1}/${entry.item.totalItems}]`);
+	if (![
+		"general",
+		"api",
+		"config"
+	].includes(entry.context)) logPrefix.push(`[${entry.context}]`);
+	if (entry.level === "error") logPrefix.push(`❌`);
+	if (entry.item?.uniqueItemId) log(...logPrefix, ...entry.content, `(${entry.item?.uniqueItemId})`);
+	else log(...logPrefix, ...entry.content);
+};
+const log = {
+	item: (item) => ({
+		process(level, context, ...content) {
+			const entry = {
+				timestamp: /* @__PURE__ */ new Date(),
+				level,
+				item,
+				source: "process",
+				context,
+				content
+			};
+			renderLog(entry);
+			logMemory.push({
+				...entry,
+				content: serializeErrors(content)
+			});
+		},
+		browser(level, context, ...content) {
+			const entry = {
+				timestamp: /* @__PURE__ */ new Date(),
+				level,
+				item,
+				source: "browser",
+				context,
+				content
+			};
+			renderLog(entry);
+			logMemory.push({
+				...entry,
+				content: serializeErrors(content)
+			});
+		}
+	}),
+	process(level, context, ...content) {
+		const entry = {
+			timestamp: /* @__PURE__ */ new Date(),
+			level,
+			source: "process",
+			context,
+			content
+		};
+		renderLog(entry);
+		logMemory.push({
+			...entry,
+			content: serializeErrors(content)
+		});
+	},
+	browser(level, context, ...content) {
+		const entry = {
+			timestamp: /* @__PURE__ */ new Date(),
+			level,
+			source: "browser",
+			context,
+			content
+		};
+		renderLog(entry);
+		logMemory.push({
+			...entry,
+			content: serializeErrors(content)
+		});
+	}
+};
+//#endregion
+//#region src/configHelper.ts
+const loadProjectConfigFile = async (configFilepath) => {
+	try {
+		const { mod } = await bundleRequire({
+			filepath: configFilepath,
+			esbuildOptions: {}
+		});
+		return mod?.default ?? mod?.config ?? mod;
+	} catch (error) {
+		log.process("error", "config", error);
+		throw error;
+	}
+};
+const loadTSProjectConfigFile = async (configFilepath) => {
+	try {
+		const imported = await import(configFilepath);
+		return imported?.default ?? imported?.config;
+	} catch (error) {
+		if (["ERR_MODULE_NOT_FOUND", "MODULE_NOT_FOUND"].includes(error.code)) {
+			log.process("error", "config", "Failed to load TypeScript configuration file");
+			process.exit(1);
+		}
+		log.process("error", "config", error);
+		process.exit(1);
+	}
+};
+//#endregion
+//#region src/schemas.ts
+const BrowserSchema = z$1.enum([
+	"chromium",
+	"firefox",
+	"webkit"
+]);
+const ShotModeSchema = z$1.enum([
+	"storybook",
+	"ladle",
+	"histoire",
+	"page",
+	"custom"
+]);
+const MaskSchema = z$1.object({ selector: z$1.string() });
+z$1.object({
+	shotMode: ShotModeSchema,
+	id: z$1.string(),
+	shotName: z$1.string(),
+	url: z$1.string(),
+	filePathBaseline: z$1.string(),
+	filePathCurrent: z$1.string(),
+	filePathDifference: z$1.string(),
+	browserConfig: z$1.custom().optional(),
+	threshold: z$1.number(),
+	waitBeforeScreenshot: z$1.number().optional(),
+	importPath: z$1.string().optional(),
+	mask: z$1.array(MaskSchema).optional(),
+	viewport: z$1.object({
+		width: z$1.number(),
+		height: z$1.number().optional()
+	}).optional(),
+	breakpoint: z$1.number().optional(),
+	breakpointGroup: z$1.string().optional(),
+	elementLocator: z$1.string().optional(),
+	waitForSelector: z$1.string().optional(),
+	componentPath: z$1.string().optional(),
+	storyName: z$1.string().optional(),
+	storyId: z$1.string().optional(),
+	storyArgs: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	tags: z$1.array(z$1.string()).optional()
+});
+//#endregion
+//#region src/config.ts
+const PageScreenshotParameterSchema = z$1.object({
+	path: z$1.string(),
+	name: z$1.string(),
+	waitBeforeScreenshot: z$1.number().default(1e3),
+	threshold: z$1.number().default(0),
+	breakpoints: z$1.array(z$1.number()).optional(),
+	viewport: z$1.object({
+		width: z$1.number().optional(),
+		height: z$1.number().optional()
+	}).optional(),
+	mask: z$1.array(MaskSchema).optional()
+});
+const StorybookShotsSchema = z$1.object({
+	storybookUrl: z$1.string(),
+	mask: z$1.array(MaskSchema).optional(),
+	breakpoints: z$1.array(z$1.number()).optional(),
+	elementLocator: z$1.string().optional(),
+	waitForSelector: z$1.string().optional()
+});
+const LadleShotsSchema = z$1.object({
+	ladleUrl: z$1.string(),
+	mask: z$1.array(MaskSchema).optional(),
+	breakpoints: z$1.array(z$1.number()).optional(),
+	waitForSelector: z$1.string().optional()
+});
+const HistoireShotsSchema = z$1.object({
+	histoireUrl: z$1.string(),
+	mask: z$1.array(MaskSchema).optional(),
+	breakpoints: z$1.array(z$1.number()).optional(),
+	waitForSelector: z$1.string().optional()
+});
+const PageShotsSchema = z$1.object({
+	pages: z$1.array(PageScreenshotParameterSchema),
+	pagesJsonUrl: z$1.string().optional(),
+	pagesJsonRefiner: z$1.custom().optional(),
+	baseUrl: z$1.string(),
+	mask: z$1.array(MaskSchema).optional(),
+	breakpoints: z$1.array(z$1.number()).optional(),
+	waitForSelector: z$1.string().optional()
+});
+const CustomShotsSchema = z$1.object({ currentShotsPath: z$1.string() });
+z$1.object({
+	shotMode: ShotModeSchema,
+	id: z$1.string().optional(),
+	kind: z$1.string().optional(),
+	story: z$1.string().optional(),
+	shotName: z$1.string().optional(),
+	parameters: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	filePathBaseline: z$1.string().optional(),
+	filePathCurrent: z$1.string().optional(),
+	filePathDifference: z$1.string().optional()
+});
+z$1.object({
+	shotMode: ShotModeSchema,
+	id: z$1.string(),
+	shotName: z$1.string(),
+	url: z$1.string(),
+	filePathBaseline: z$1.string(),
+	filePathCurrent: z$1.string(),
+	filePathDifference: z$1.string(),
+	browserConfig: z$1.custom().optional(),
+	threshold: z$1.number(),
+	waitBeforeScreenshot: z$1.number().optional(),
+	importPath: z$1.string().optional(),
+	mask: z$1.array(MaskSchema).optional(),
+	viewport: z$1.object({
+		width: z$1.number(),
+		height: z$1.number().optional()
+	}).optional(),
+	breakpoint: z$1.number().optional(),
+	breakpointGroup: z$1.string().optional(),
+	elementLocator: z$1.string().optional(),
+	waitForSelector: z$1.string().optional()
+});
+const TimeoutsSchema = z$1.object({
+	fetchStories: z$1.number().default(3e4),
+	loadState: z$1.number().default(3e4),
+	networkRequests: z$1.number().default(3e4)
+});
+const BaseConfigSchema = z$1.object({
+	browser: z$1.union([BrowserSchema, z$1.array(BrowserSchema).default(["chromium"])]).default("chromium"),
+	storybookShots: StorybookShotsSchema.optional(),
+	ladleShots: LadleShotsSchema.optional(),
+	histoireShots: HistoireShotsSchema.optional(),
+	pageShots: PageShotsSchema.optional(),
+	customShots: CustomShotsSchema.optional(),
+	imagePathCurrent: z$1.string().default(".thirdeye/current/"),
+	breakpoints: z$1.array(z$1.number()).optional(),
+	shotConcurrency: z$1.number().default(5),
+	timeouts: TimeoutsSchema.default({
+		fetchStories: 3e4,
+		loadState: 3e4,
+		networkRequests: 3e4
+	}),
+	waitBeforeScreenshot: z$1.number().default(1e3),
+	waitForFirstRequest: z$1.number().default(1e3),
+	waitForLastRequest: z$1.number().default(1e3),
+	threshold: z$1.number().default(0),
+	turboSnap: z$1.boolean().optional().default(false),
+	flakynessRetries: z$1.number().default(0),
+	waitBetweenFlakynessRetries: z$1.number().default(2e3),
+	filterShot: z$1.custom().optional(),
+	shotNameGenerator: z$1.custom().optional(),
+	configureBrowser: z$1.custom().optional(),
+	beforeScreenshot: z$1.custom().optional(),
+	afterScreenshot: z$1.custom().optional(),
+	browserLaunchOptions: z$1.object({
+		chromium: z$1.custom().optional(),
+		firefox: z$1.custom().optional(),
+		webkit: z$1.custom().optional()
+	}).optional()
+});
+const PlatformModeConfigSchema = BaseConfigSchema.extend({
+	thirdEyePlatform: z$1.string().default("https://third-eye.gfxlabs.cloud"),
+	apiKey: z$1.string(),
+	thirdEyeProjectId: z$1.string({ error: "Required" }).default(process.env.THIRD_EYE_PROJECT_ID),
+	thirdEyeOrgId: z$1.string({ error: "Required" }).default(process.env.THIRD_EYE_ORG_ID),
+	ciBuildId: z$1.string({ error: "Required (can be set via `CI_BUILD_ID` env variable)" }).default(process.env.CI_BUILD_ID),
+	ciBuildNumber: z$1.string({ error: "Required (can be set via `CI_BUILD_NUMBER` env variable)" }).default(process.env.CI_BUILD_NUMBER),
+	repository: z$1.string({ error: "Required (can be set via `REPOSITORY` env variable)" }).default(process.env.REPOSITORY ?? process.env.GITHUB_REPOSITORY),
+	commitRefName: z$1.string({ error: "Required (can be set via `COMMIT_REF_NAME` env variable)" }).default(process.env.COMMIT_REF_NAME ?? process.env.GITHUB_HEAD_REF ?? process.env.GITHUB_REF_NAME),
+	commitHash: z$1.string({ error: "Required (can be set via `COMMIT_HASH` env variable)" }).default(process.env.COMMIT_HASH ?? process.env.GITHUB_SHA),
+	baseBranch: z$1.string().optional().default(process.env.GITHUB_BASE_REF ?? ""),
+	prNumber: z$1.coerce.number().optional().default(process.env.THIRD_EYE_PR_NUMBER ? Number(process.env.THIRD_EYE_PR_NUMBER) : void 0),
+	setPendingStatusCheck: z$1.boolean().default(false),
+	storybookStaticDir: z$1.string().optional()
+});
+const GenerateOnlyModeConfigSchema = BaseConfigSchema.extend({
+	generateOnly: z$1.boolean().optional(),
+	failOnDifference: z$1.boolean().optional(),
+	imagePathBaseline: z$1.string().default(".thirdeye/baseline/"),
+	imagePathDifference: z$1.string().default(".thirdeye/difference/"),
+	compareConcurrency: z$1.number().default(10),
+	compareEngine: z$1.enum(["pixelmatch", "odiff"]).default("pixelmatch"),
+	filterItemsToCheck: z$1.custom().optional()
+});
+z$1.union([PlatformModeConfigSchema, GenerateOnlyModeConfigSchema]);
+z$1.union([PlatformModeConfigSchema.extend({
+	timeouts: TimeoutsSchema.partial(),
+	pageShots: PageShotsSchema.extend({ pages: z$1.array(PageScreenshotParameterSchema.partial()) })
+}).partial(), GenerateOnlyModeConfigSchema.extend({
+	timeouts: TimeoutsSchema.partial(),
+	pageShots: PageShotsSchema.extend({ pages: z$1.array(PageScreenshotParameterSchema.partial()) })
+}).partial()]);
+let config;
+const isPlatformModeConfig = (userConfig) => "apiKey" in userConfig && typeof userConfig.apiKey === "string" || "thirdEyeProjectId" in userConfig && typeof userConfig.thirdEyeProjectId === "string" || "thirdEyeOrgId" in userConfig && typeof userConfig.thirdEyeOrgId === "string";
+const printConfigErrors = (error) => {
+	for (const issue of error.issues) log.process("error", "config", [
+		"Configuration error:",
+		`  - Path: ${issue.path.join(".")}`,
+		`  - Message: ${issue.message}`
+	].join("\n"));
+};
+const parseConfig = (userConfig) => {
+	if (isPlatformModeConfig(userConfig)) {
+		const platformCheck = PlatformModeConfigSchema.safeParse(userConfig);
+		if (platformCheck.success) return platformCheck.data;
+		printConfigErrors(platformCheck.error);
+	} else {
+		const generateOnlyCheck = GenerateOnlyModeConfigSchema.safeParse(userConfig);
+		if (generateOnlyCheck.success) return generateOnlyCheck.data;
+		printConfigErrors(generateOnlyCheck.error);
+	}
+	throw new Error("Configuration error");
+};
+const configDirBase = process.env.THIRD_EYE_CONFIG_DIR ?? process.cwd();
+const configFileNameBase = path.join(path.isAbsolute(configDirBase) ? "" : process.cwd(), configDirBase, "thirdeye.config");
+const loadProjectConfig = async () => {
+	log.process("info", "config", "Loading project config ...");
+	log.process("info", "config", "Current working directory:", process.cwd());
+	if (process.env.THIRD_EYE_CONFIG_DIR) log.process("info", "config", "Defined config directory:", process.env.THIRD_EYE_CONFIG_DIR);
+	const configExtensions = [
+		"ts",
+		"js",
+		"cjs",
+		"mjs"
+	];
+	const configExtensionsString = configExtensions.join("|");
+	log.process("info", "config", "Looking for config file:", `${configFileNameBase}.(${configExtensionsString})`);
+	const configFiles = configExtensions.map((ext) => `${configFileNameBase}.${ext}`).filter((file) => existsSync(file));
+	if (configFiles.length === 0) {
+		log.process("error", "config", `Couldn't find project config file 'thirdeye.config.(${configExtensionsString})'`);
+		process.exit(1);
+	}
+	if (configFiles.length > 1) log.process("info", "config", "✅ Found multiple config files, taking:", configFiles[0]);
+	else log.process("info", "config", "✅ Found config file:", configFiles[0]);
+	const configFile = configFiles[0];
+	try {
+		return await loadProjectConfigFile(configFile);
+	} catch {
+		log.process("error", "config", "Loading config using ESBuild failed, using fallback option");
+		try {
+			if (existsSync(`${configFileNameBase}.js`)) {
+				const imported = await import(`${configFileNameBase}.js`);
+				const projectConfig = imported?.default ?? imported?.config ?? imported;
+				log.process("info", "config", "✅ Successfully loaded configuration from:", `${configFileNameBase}.js`);
+				return projectConfig;
+			}
+			if (existsSync(`${configFileNameBase}.ts`)) {
+				const imported = await loadTSProjectConfigFile(configFile);
+				log.process("info", "config", "✅ Successfully loaded configuration from:", `${configFileNameBase}.ts`);
+				return imported;
+			}
+			log.process("error", "config", "Couldn't find project config file 'thirdeye.config.js'");
+			process.exit(1);
+		} catch (error) {
+			log.process("error", "config", `Failed to load config file: ${configFile}`);
+			log.process("error", "config", error);
+			process.exit(1);
+		}
+	}
+};
+const configure = async ({ customProjectConfig, localDebugMode }) => {
+	if (customProjectConfig) {
+		config = parseConfig(customProjectConfig);
+		return;
+	}
+	let loadedProjectConfig = await loadProjectConfig();
+	if (localDebugMode) {
+		let localDebugConfig = loadedProjectConfig;
+		if (isPlatformModeConfig(loadedProjectConfig)) localDebugConfig = {
+			...loadedProjectConfig,
+			generateOnly: true,
+			thirdEyeProjectId: void 0,
+			apiKey: void 0
+		};
+		if (localDebugConfig.pageShots?.baseUrl && [
+			"http://",
+			"https://",
+			"127.0.0.1"
+		].some((urlChunk) => localDebugConfig?.pageShots?.baseUrl.includes(urlChunk))) {
+			const url = new URL(localDebugConfig.pageShots.baseUrl);
+			url.hostname = "localhost";
+			localDebugConfig.pageShots.baseUrl = url.toString();
+		}
+		loadedProjectConfig = localDebugConfig;
+	}
+	if (!loadedProjectConfig.storybookShots && !loadedProjectConfig.pageShots && !loadedProjectConfig.ladleShots && !loadedProjectConfig.histoireShots && !loadedProjectConfig.customShots) loadedProjectConfig.storybookShots = { storybookUrl: "storybook-static" };
+	config = parseConfig(loadedProjectConfig);
+};
+//#endregion
+//#region src/constants.ts
+const notSupported = "not supported";
+const POST_HOG_API_KEY = "phc_RDNnzvANh1mNm9JKogF9UunG3Ky02YCxWP9gXScKShk";
+//#endregion
+//#region src/utils.ts
+const isUpdateMode = () => {
+	const args = yargs(hideBin(process.argv)).parseSync();
+	return args._.includes("update") || args.m === "update" || process.env.THIRD_EYE_MODE === "update";
+};
+const isSitemapPageGenMode = () => {
+	return yargs(hideBin(process.argv)).parseSync()._.includes("page-sitemap-gen") || process.env.THIRD_EYE_MODE === "page-sitemap-gen";
+};
+const isDockerMode = () => {
+	return yargs(hideBin(process.argv)).parseSync()._.includes("docker") || process.env.THIRD_EYE_DOCKER === "true";
+};
+const isLocalDebugMode = () => {
+	return yargs(hideBin(process.argv)).parseSync()._.includes("local") || process.env.THIRD_EYE_LOCAL === "true";
+};
+const shallGenerateMeta = () => {
+	return yargs(hideBin(process.argv)).parseSync()._.includes("meta") || process.env.THIRD_EYE_GENERATE_META === "true";
+};
+const createShotsFolders = () => {
+	const paths = isPlatformModeConfig(config) ? [config.imagePathCurrent] : [
+		config.imagePathBaseline,
+		config.imagePathCurrent,
+		config.imagePathDifference
+	];
+	for (const path of paths) if (!existsSync(path)) mkdirSync(path, { recursive: true });
+	const ignoreFile = normalize(join(config.imagePathCurrent, "..", ".gitignore"));
+	if (!existsSync(ignoreFile)) writeFileSync(ignoreFile, "current\ndifference\n");
+};
+const sleep = async (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const removeFilesInFolder = (path, excludePaths) => {
+	const filesPathsIgnoringExclude = readdirSync(path).map((file) => join(path, file)).filter((filePath) => !excludePaths?.includes(filePath));
+	log.process("info", "general", `Removing ${filesPathsIgnoringExclude.length} files from ${path}`);
+	for (const filePath of filesPathsIgnoringExclude) unlinkSync(filePath);
+};
+const convertBrowser = (browserKey) => {
+	switch (browserKey) {
+		case "chromium": return chromium;
+		case "firefox": return firefox;
+		case "webkit": return webkit;
+		default: return chromium;
+	}
+};
+const getBrowser = () => {
+	if (Array.isArray(config.browser)) return convertBrowser(config.browser[0]);
+	return convertBrowser(config.browser);
+};
+const getBrowsers = () => {
+	if (!Array.isArray(config.browser) || config.browser.length === 0) return [getBrowser()];
+	const browsers = config.browser.map((key) => convertBrowser(key));
+	return [...new Set(browsers)];
+};
+const getVersion = () => {
+	try {
+		const packageJsonPath = new URL("../package.json", import.meta.url);
+		return JSON.parse(readFileSync(packageJsonPath, "utf8")).version;
+	} catch {}
+};
+const fileNameWithoutExtension = (fileName) => {
+	return fileName.split(".").slice(0, -1).join(".");
+};
+const readDirIntoShotItems = (path) => {
+	return readdirSync(path).filter((name) => name.endsWith(".png")).map((fileNameWithExt) => {
+		const fileName = fileNameWithoutExtension(fileNameWithExt);
+		return {
+			id: fileName,
+			shotName: fileName,
+			shotMode: "custom",
+			filePathBaseline: isPlatformModeConfig(config) ? notSupported : join(config.imagePathBaseline, fileNameWithExt),
+			filePathCurrent: join(path, fileNameWithExt),
+			filePathDifference: isPlatformModeConfig(config) ? notSupported : join(config.imagePathDifference, fileNameWithExt),
+			url: fileName,
+			threshold: config.threshold
+		};
+	});
+};
+const sendTelemetryData = async (properties) => {
+	const client = new PostHog(POST_HOG_API_KEY);
+	const id = randomUUID();
+	try {
+		log.process("info", "general", "Sending anonymized telemetry data.");
+		const version = getVersion();
+		const modes = [];
+		if (config.storybookShots) modes.push("storybook");
+		if (config.ladleShots) modes.push("ladle");
+		if (config.pageShots) modes.push("pages");
+		if (config.customShots) modes.push("custom");
+		if (properties.error) client.capture({
+			distinctId: id,
+			event: "third-eye-error",
+			properties: { ...properties }
+		});
+		else client.capture({
+			distinctId: id,
+			event: "third-eye-run",
+			properties: {
+				...properties,
+				version,
+				modes
+			}
+		});
+		await client.shutdown();
+	} catch (error) {
+		log.process("error", "general", "Error when sending telemetry data", error);
+	}
+};
+const parseHrtimeToSeconds = (hrtime) => {
+	return (hrtime[0] + hrtime[1] / 1e9).toFixed(3);
+};
+const exitProcess = async (properties) => {
+	if (process.env.THIRD_EYE_DISABLE_TELEMETRY === "1") process.exit(properties.exitCode ?? 1);
+	else await sendTelemetryData(properties).finally(() => {
+		process.exit(properties.exitCode ?? 1);
+	});
+};
+const hashBuffer = (buffer) => {
+	const hashSum = crypto.createHash("sha256");
+	hashSum.update(buffer);
+	return hashSum.digest("hex");
+};
+const hashFile = (filePath) => {
+	return hashBuffer(readFileSync(filePath));
+};
+const featureNotSupported = (feature) => {
+	log.process("error", "general", `${feature} is not supported in this configuration mode`);
+	process.exit(1);
+};
+const launchBrowser = async (_browser) => {
+	const browserType = _browser ?? getBrowser();
+	const browserName = browserType.name();
+	return browserType.launch(config.browserLaunchOptions?.[browserName]);
+};
+//#endregion
+//#region src/compare/utils.ts
+const resizeImage = (originalImage, width, height) => {
+	const newImage = new PNG({
+		width,
+		height,
+		fill: true,
+		inputHasAlpha: true
+	});
+	for (let x = 0; x < width; x++) for (let y = 0; y < height; y++) {
+		const index = (width * y + x << 2) + 3;
+		newImage.data[index] = 64;
+	}
+	PNG.bitblt(originalImage, newImage, 0, 0, originalImage.width, originalImage.height, 0, 0);
+	return newImage;
+};
+//#endregion
+//#region src/compare/compare.ts
+const checkThreshold = (threshold, pixelsTotal, pixelDifference) => {
+	if (threshold < 1) return pixelDifference <= pixelsTotal * threshold;
+	return pixelDifference <= threshold;
+};
+const compareImagesViaPixelmatch = async (threshold, baselineShotPath, currentShotPath, differenceShotPath) => {
+	const baselineImageBuffer = readFileSync(baselineShotPath);
+	const currentImageBuffer = readFileSync(currentShotPath);
+	if (baselineImageBuffer.equals(currentImageBuffer)) return {
+		pixelDifference: 0,
+		pixelDifferencePercentage: 0,
+		isWithinThreshold: true
+	};
+	let baselineImage = PNG.sync.read(baselineImageBuffer);
+	let currentImage = PNG.sync.read(currentImageBuffer);
+	const maxWidth = Math.max(baselineImage.width || 100, currentImage.width || 100);
+	const maxHeight = Math.max(baselineImage.height || 100, currentImage.height || 100);
+	if (baselineImage.width !== currentImage.width || baselineImage.height !== currentImage.height) {
+		baselineImage = resizeImage(baselineImage, maxWidth, maxHeight);
+		currentImage = resizeImage(currentImage, maxWidth, maxHeight);
+	}
+	const differenceImage = new PNG({
+		width: maxWidth,
+		height: maxHeight
+	});
+	const pixelDifference = pixelmatch(baselineImage.data, currentImage.data, differenceImage.data, maxWidth, maxHeight, { threshold: 0 });
+	const pixelsTotal = baselineImage.width * baselineImage.height;
+	if (pixelDifference > 0 && differenceShotPath) {
+		const isWithinThreshold = checkThreshold(threshold, pixelsTotal, pixelDifference);
+		if (!isWithinThreshold) writeFileSync(differenceShotPath, PNG.sync.write(differenceImage));
+		return {
+			pixelDifference,
+			pixelDifferencePercentage: pixelDifference / pixelsTotal,
+			isWithinThreshold
+		};
+	}
+	return {
+		pixelDifference,
+		pixelDifferencePercentage: pixelDifference / pixelsTotal,
+		isWithinThreshold: true
+	};
+};
+const compareImagesViaOdiff = async (threshold, baselineShotPath, currentShotPath, differenceShotPath) => {
+	const result = await compare(baselineShotPath, currentShotPath, differenceShotPath, { failOnLayoutDiff: false });
+	if (result.match) return {
+		pixelDifference: 0,
+		pixelDifferencePercentage: 0,
+		isWithinThreshold: true
+	};
+	if (result.reason === "pixel-diff") {
+		let isWithinThreshold = true;
+		const pixelDifferencePercentage = Number(result.diffPercentage / 100);
+		if (threshold < 1) isWithinThreshold = pixelDifferencePercentage <= threshold;
+		else isWithinThreshold = result.diffCount <= threshold;
+		return {
+			pixelDifference: Number(result.diffCount),
+			pixelDifferencePercentage,
+			isWithinThreshold
+		};
+	}
+	throw new Error("Couldn't compare images");
+};
+const compareImages = async (threshold, baselineShotPath, currentShotPath, differenceShotPath) => {
+	if (isPlatformModeConfig(config)) return featureNotSupported("compareImages()");
+	if (config.compareEngine === "pixelmatch") return compareImagesViaPixelmatch(threshold, baselineShotPath, currentShotPath, differenceShotPath);
+	return compareImagesViaOdiff(threshold, baselineShotPath, currentShotPath, differenceShotPath);
+};
+//#endregion
+//#region src/checkDifferences.ts
+const checkDifferences = async (shotItems) => {
+	if (isPlatformModeConfig(config)) return featureNotSupported("checkDifferences()");
+	log.process("info", "general", `Comparing ${shotItems.length} screenshots using '${config.compareEngine}' as compare engine`);
+	const total = shotItems.length;
+	const noBaselinesItems = [];
+	const aboveThresholdDifferenceItems = [];
+	const comparisonResults = {};
+	await mapLimit(shotItems.entries(), config.compareConcurrency, async (item) => {
+		const [index, shotItem] = item;
+		const logger = (message) => {
+			log.item({
+				shotMode: shotItem.shotMode,
+				uniqueItemId: shotItem.shotName,
+				itemIndex: index,
+				totalItems: total
+			}).process("info", "general", message);
+		};
+		logger(`Comparing '${shotItem.id}'`);
+		if (!existsSync(shotItem.filePathBaseline)) {
+			logger("Baseline image missing. Will be treated as addition.");
+			noBaselinesItems.push(shotItem);
+			return;
+		}
+		if (!existsSync(shotItem.filePathCurrent)) throw new Error(`Error: Missing current image: ${shotItem.filePathCurrent}`);
+		const { pixelDifference, pixelDifferencePercentage, isWithinThreshold } = await compareImages(shotItem.threshold, shotItem.filePathBaseline, shotItem.filePathCurrent, shotItem.filePathDifference);
+		if (shallGenerateMeta()) comparisonResults[shotItem.id] = {
+			pixelDifference,
+			pixelDifferencePercentage,
+			isWithinThreshold
+		};
+		if (pixelDifference > 0) {
+			const percentage = (pixelDifferencePercentage * 100).toFixed(2);
+			if (isWithinThreshold) logger(`Difference of ${pixelDifference} pixels (${percentage}%) found but within threshold.`);
+			else {
+				aboveThresholdDifferenceItems.push(shotItem);
+				logger(`Difference of ${pixelDifference} pixels (${percentage}%) found. Difference image saved to: ${shotItem.filePathDifference}`);
+			}
+		} else logger("No difference found.");
+	});
+	if (shallGenerateMeta()) {
+		log.process("info", "general", `Writing meta file with ${Object.entries(comparisonResults).length} items.`);
+		writeFileSync(`${path.join(config.imagePathCurrent, "meta")}.json`, JSON.stringify(comparisonResults, null, 2));
+	}
+	log.process("info", "general", "Comparison done!");
+	return {
+		aboveThresholdDifferenceItems,
+		noBaselinesItems
+	};
+};
+//#endregion
+//#region src/shots/utils.ts
+const checkIgnoreUrls = (url, ignoreUrls) => {
+	for (const ignoreUrl of ignoreUrls) if (url.includes(ignoreUrl)) return true;
+	return false;
+};
+const waitForNetworkRequests = async ({ page, logger, timeout = config.timeouts.networkRequests, waitForFirstRequest = config.waitForFirstRequest, waitForLastRequest = config.waitForLastRequest, ignoreUrls = [] }) => new Promise((resolve, reject) => {
+	let requestCounter = 0;
+	const requests = /* @__PURE__ */ new Set();
+	let lastRequestTimeoutId;
+	const timeoutId = setTimeout(() => {
+		const pendingUrls = [...requests].map((request) => request.url());
+		logger.process("info", "network", "Pending requests:", pendingUrls);
+		cleanup();
+		reject(/* @__PURE__ */ new Error("Timeout"));
+	}, timeout);
+	const firstRequestTimeoutId = setTimeout(() => {
+		cleanup();
+		resolve(true);
+	}, waitForFirstRequest);
+	const onRequest = (request) => {
+		if (!checkIgnoreUrls(request.url(), ignoreUrls)) {
+			clearTimeout(firstRequestTimeoutId);
+			clearTimeout(lastRequestTimeoutId);
+			requestCounter++;
+			requests.add(request);
+			logger.browser("info", "network", `+ ${request.url()}`);
+		}
+	};
+	const onRequestFinished = async (request) => {
+		clearTimeout(lastRequestTimeoutId);
+		if (!checkIgnoreUrls(request.url(), ignoreUrls)) {
+			const failure = request.failure();
+			const response = await request.response();
+			requestCounter--;
+			requests.delete(request);
+			const statusText = failure ? failure.errorText : `${response?.status() ?? "unknown"} ${response?.statusText() ?? "unknown"}`;
+			logger.browser("info", "network", `- ${request.url()} [${statusText}]`);
+		}
+		lastRequestTimeoutId = setTimeout(() => {
+			if (requestCounter <= 0) {
+				cleanup();
+				resolve(true);
+			}
+		}, waitForLastRequest);
+	};
+	function cleanup() {
+		clearTimeout(timeoutId);
+		clearTimeout(firstRequestTimeoutId);
+		clearTimeout(lastRequestTimeoutId);
+		page.removeListener("request", onRequest);
+		page.removeListener("requestfinished", onRequestFinished);
+		page.removeListener("requestfailed", onRequestFinished);
+	}
+	page.on("request", onRequest);
+	page.on("requestfinished", onRequestFinished);
+	page.on("requestfailed", onRequestFinished);
+});
+const resizeViewportToFullscreen = async ({ page }) => {
+	const viewport = await page.evaluate(async () => new Promise((resolve) => {
+		const { body } = document;
+		const html = document.documentElement;
+		resolve({
+			height: Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight),
+			width: Math.max(body.scrollWidth, body.offsetWidth, html.clientWidth, html.scrollWidth, html.offsetWidth)
+		});
+	}));
+	await page.setViewportSize({
+		width: Math.max(page.viewportSize()?.width ?? 800, viewport.width),
+		height: viewport.height
+	});
+};
+const selectBreakpoints = (topLevelBreakpoints, modeBreakpoints, shotBreakpoints) => {
+	if (shotBreakpoints && shotBreakpoints.length > 0) return shotBreakpoints;
+	if (modeBreakpoints && modeBreakpoints.length > 0) return modeBreakpoints;
+	return topLevelBreakpoints ?? [];
+};
+const generateLabel = ({ breakpoint, browser }) => {
+	const labels = [breakpoint && breakpoint > 0 ? `w${breakpoint}px` : "", browser?.name() ?? ""].filter(Boolean);
+	if (labels.length === 0) return "";
+	return `__[${labels.join("|")}]`;
+};
+//#endregion
+//#region src/crawler/ladleScreenshots.ts
+const generateLadleShotItems = (baseUrl, isLocalServer, ladleStories, mask, modeBreakpoints, browser) => {
+	const ladleUrl = isLocalServer ? `${baseUrl}/index.html` : baseUrl;
+	return ladleStories.filter((story) => story.parameters?.thirdeye?.disable !== true).filter((story) => config.filterShot ? config.filterShot({
+		...story,
+		shotMode: "ladle"
+	}) : true).flatMap((ladleStory) => {
+		const shotName = config.shotNameGenerator?.({
+			...ladleStory,
+			shotMode: "ladle"
+		}) ?? ladleStory.id;
+		let label = generateLabel({ browser });
+		let fileNameWithExt = `${shotName}${label}.png`;
+		const shotItem = {
+			shotMode: "ladle",
+			id: `${ladleStory.story}${label}`,
+			shotName: `${shotName}${label}`,
+			importPath: ladleStory.importPath,
+			url: `${ladleUrl}?story=${ladleStory.story}&mode=preview`,
+			filePathBaseline: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathBaseline, fileNameWithExt),
+			filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+			filePathDifference: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathDifference, fileNameWithExt),
+			threshold: ladleStory.parameters?.thirdeye?.threshold ?? config.threshold,
+			waitBeforeScreenshot: ladleStory.parameters?.thirdeye?.waitBeforeScreenshot ?? config.waitBeforeScreenshot,
+			mask: [...mask ?? [], ...ladleStory.parameters?.thirdeye?.mask ?? []],
+			elementLocator: ladleStory.parameters?.thirdeye?.elementLocator ?? config?.storybookShots?.elementLocator ?? "",
+			waitForSelector: config?.ladleShots?.waitForSelector ?? "[data-storyloaded]",
+			componentPath: ladleStory.kind,
+			storyName: ladleStory.story
+		};
+		const breakpoints = selectBreakpoints(config.breakpoints, modeBreakpoints, ladleStory.parameters?.thirdeye?.breakpoints);
+		if (breakpoints.length === 0) return [shotItem];
+		return breakpoints.map((breakpoint) => {
+			label = generateLabel({
+				breakpoint,
+				browser
+			});
+			fileNameWithExt = `${shotName}${label}.png`;
+			return {
+				...shotItem,
+				id: `${ladleStory.story}${label}`,
+				shotName: `${ladleStory.story}${label}`,
+				breakpoint,
+				breakpointGroup: ladleStory.story,
+				url: `${ladleUrl}?story=${ladleStory.story}&mode=preview&width=${breakpoint}`,
+				filePathBaseline: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathBaseline, fileNameWithExt),
+				filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+				filePathDifference: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathDifference, fileNameWithExt),
+				viewport: { width: breakpoint }
+			};
+		});
+	});
+};
+const collectLadleStories = async (ladleUrl) => {
+	const { data } = await axios.get(`${ladleUrl}/meta.json`);
+	const collection = [];
+	for (const [key, storyConfig] of Object.entries(data.stories)) collection.push({
+		id: key,
+		story: key,
+		kind: key,
+		importPath: storyConfig.filePath,
+		parameters: storyConfig.meta
+	});
+	return collection;
+};
+//#endregion
+//#region src/crawler/storybook.ts
+const kebabCase = (str) => (str ?? "").replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/[\s_/]+/g, "-").toLowerCase();
+const getStoryBookUrl = (url) => {
+	if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("file://")) return url;
+	if (url.startsWith("/")) return `file://${url}`;
+	return `file://${path.normalize(path.join(process.cwd(), url))}`;
+};
+const getIframeUrl = (url) => url.endsWith("/") ? `${url}iframe.html` : `${url}/iframe.html`;
+const collectStoriesViaWindowApi = async (context, url, isIframeUrl) => {
+	const page = await context.newPage();
+	const iframeUrl = isIframeUrl ? getStoryBookUrl(url) : getIframeUrl(getStoryBookUrl(url));
+	await page.goto(iframeUrl);
+	await page.waitForFunction(() => window.__STORYBOOK_PREVIEW__, null, { timeout: config.timeouts.fetchStories });
+	if (await page.evaluate(async () => {
+		const { __STORYBOOK_PREVIEW__: api } = window;
+		return api.ready !== void 0;
+	})) await page.evaluate(async () => {
+		const { __STORYBOOK_PREVIEW__: api } = window;
+		if (api.ready) await api.ready();
+	});
+	else {
+		await page.waitForFunction(() => window.__STORYBOOK_CLIENT_API__, null, { timeout: config.timeouts.fetchStories });
+		await page.evaluate(async () => {
+			const { __STORYBOOK_CLIENT_API__: api } = window;
+			if (api.storyStore) await api.storyStore.cacheAllCSFFiles?.();
+		});
+	}
+	return await page.evaluate(async () => {
+		const parseParameters = (parameters, level = 0) => {
+			if (level > 10) return "UNSUPPORTED_DEPTH";
+			if (Array.isArray(parameters)) return parameters.map((value) => parseParameters(value, level + 1));
+			if (typeof parameters === "string" || typeof parameters === "number" || typeof parameters === "boolean" || parameters === void 0 || typeof parameters === "function" || parameters instanceof RegExp || parameters instanceof Date || parameters === null) return parameters;
+			if (typeof parameters === "object" && parameters !== null) return Object.keys(parameters).reduce((acc, key) => {
+				acc[key] = parseParameters(parameters[key], level + 1);
+				return acc;
+			}, {});
+			return "UNSUPPORTED_TYPE";
+		};
+		const mapStories = (stories) => stories.map((story) => {
+			const parameters = parseParameters(story.parameters);
+			return {
+				id: story.id,
+				kind: story.kind,
+				story: story.story,
+				importPath: parameters?.fileName,
+				parameters
+			};
+		});
+		const { __STORYBOOK_PREVIEW__: previewApi, __STORYBOOK_CLIENT_API__: clientApi } = window;
+		let stories = [];
+		if (previewApi.extract) {
+			const items = await previewApi.extract();
+			stories = mapStories(Object.values(items));
+		} else if (clientApi.raw) stories = mapStories(clientApi.raw());
+		return { stories };
+	});
+};
+const collectStoriesViaStoriesJson = async (context, url) => {
+	const indexJsonUrl = url.endsWith("/") ? `${url}index.json` : `${url}/index.json`;
+	const storiesJsonUrl = url.endsWith("/") ? `${url}stories.json` : `${url}/stories.json`;
+	const tryLoadJson = async (jsonUrl) => {
+		if (jsonUrl.startsWith("file://")) try {
+			const file = readFileSync(jsonUrl.slice(7));
+			return JSON.parse(file.toString());
+		} catch {
+			return null;
+		}
+		try {
+			const result = await context.request.get(jsonUrl);
+			if (result.status() !== 200) return null;
+			return await result.json();
+		} catch {
+			return null;
+		}
+	};
+	for (const jsonUrl of [indexJsonUrl, storiesJsonUrl]) {
+		const json = await tryLoadJson(jsonUrl);
+		if (!json) continue;
+		const entries = json.entries ?? json.stories;
+		if (typeof entries === "object" && entries !== null) return { stories: Object.values(entries).filter((entry) => entry.type !== "docs").map((entry) => ({
+			...entry,
+			kind: entry.kind ?? entry.title ?? "",
+			story: entry.story ?? entry.name ?? ""
+		})) };
+	}
+	throw new Error(`Cannot load stories from ${indexJsonUrl} or ${storiesJsonUrl}`);
+};
+const collectStories = async (url) => {
+	const browser = await launchBrowser();
+	const context = await browser.newContext();
+	try {
+		log.process("info", "general", "Trying to collect stories via window object");
+		const result = await collectStoriesViaWindowApi(context, url);
+		await browser.close();
+		return result;
+	} catch (error) {
+		log.process("info", "general", "Fallback to /stories.json");
+		log.process("error", "general", error);
+	}
+	try {
+		const result = await collectStoriesViaStoriesJson(context, url);
+		await browser.close();
+		return result;
+	} catch (error) {
+		await browser.close();
+		throw error;
+	}
+};
+const generateBrowserConfig$1 = (story) => {
+	const browserConfig = config.configureBrowser?.({
+		...story,
+		shotMode: "storybook"
+	});
+	if (story.parameters?.viewport && browserConfig) {
+		browserConfig.viewport ??= {
+			width: 1280,
+			height: 720
+		};
+		browserConfig.viewport = {
+			...browserConfig.viewport,
+			...story.parameters.viewport
+		};
+	}
+	return browserConfig;
+};
+const generateStoryUrl = (iframeUrl, storyId, args, breakpoint) => {
+	let url = `${iframeUrl}?id=${storyId}&viewMode=story`;
+	if (args) {
+		const argsString = Object.entries(args).map(([key, value]) => `${key}:${value}`).join(";");
+		url += `&args=${argsString}`;
+	}
+	if (breakpoint !== void 0) url += `&width=${breakpoint}`;
+	return url;
+};
+const generateFilename = (kind, story, prefix, suffix) => {
+	return [
+		prefix,
+		kebabCase(kind),
+		kebabCase(story),
+		kebabCase(suffix)
+	].filter(Boolean).join("--");
+};
+const generateStorybookShotItems = (baseUrl, stories, mask, modeBreakpoints, browser) => {
+	const iframeUrl = getIframeUrl(getStoryBookUrl(baseUrl));
+	return stories.filter((story) => story.parameters?.thirdeye?.disable !== true).filter((story) => story.parameters?.storyshots?.disable !== true).filter((story) => config.filterShot ? config.filterShot({
+		...story,
+		shotMode: "storybook"
+	}) : true).flatMap((story) => {
+		const shotName = config.shotNameGenerator?.({
+			...story,
+			shotMode: "storybook"
+		}) ?? generateFilename(story.kind, story.story);
+		let label = generateLabel({ browser });
+		let fileNameWithExt = `${shotName}${label}.png`;
+		const baseShotItem = {
+			shotMode: "storybook",
+			id: `${story.id}${label}`,
+			shotName: `${shotName}${label}`,
+			importPath: story.importPath,
+			url: generateStoryUrl(iframeUrl, story.id, story.parameters?.thirdeye?.args),
+			filePathBaseline: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathBaseline, fileNameWithExt),
+			filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+			filePathDifference: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathDifference, fileNameWithExt),
+			browserConfig: generateBrowserConfig$1(story),
+			threshold: story.parameters?.thirdeye?.threshold ?? config.threshold,
+			waitBeforeScreenshot: story.parameters?.thirdeye?.waitBeforeScreenshot ?? config.waitBeforeScreenshot,
+			mask: [...mask ?? [], ...story.parameters?.thirdeye?.mask ?? []],
+			elementLocator: story.parameters?.thirdeye?.elementLocator ?? config?.storybookShots?.elementLocator ?? "",
+			waitForSelector: config?.storybookShots?.waitForSelector,
+			componentPath: story.kind,
+			storyName: story.story,
+			storyId: story.id,
+			storyArgs: story.parameters?.thirdeye?.args
+		};
+		const storyLevelBreakpoints = story.parameters?.thirdeye?.breakpoints ?? [];
+		const breakpoints = selectBreakpoints(config.breakpoints, modeBreakpoints, storyLevelBreakpoints);
+		let shotItems = [];
+		if (!breakpoints || breakpoints.length === 0) shotItems = [baseShotItem];
+		else shotItems = breakpoints.map((breakpoint) => {
+			label = generateLabel({
+				breakpoint,
+				browser
+			});
+			fileNameWithExt = `${shotName}${label}.png`;
+			return {
+				...baseShotItem,
+				id: `${story.id}${label}`,
+				shotName: `${shotName}${label}`,
+				breakpoint,
+				breakpointGroup: story.id,
+				filePathBaseline: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathBaseline, fileNameWithExt),
+				filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+				filePathDifference: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathDifference, fileNameWithExt),
+				viewport: {
+					width: breakpoint,
+					height: void 0
+				},
+				url: generateStoryUrl(iframeUrl, story.id, story.parameters?.thirdeye?.args, breakpoint),
+				browserConfig: generateBrowserConfig$1({
+					...story,
+					parameters: {
+						...story.parameters,
+						viewport: { width: breakpoint }
+					}
+				})
+			};
+		});
+		const extraShots = story.parameters?.thirdeye?.extraShots?.flatMap((snapshot) => {
+			const combinedArgs = {
+				...story.parameters?.thirdeye?.args,
+				...snapshot.args
+			};
+			const snapshotShotName = generateFilename(story.kind, story.story, snapshot.prefix, snapshot.suffix);
+			return (breakpoints?.length === 0 ? [void 0] : breakpoints).map((breakpoint) => {
+				label = generateLabel({
+					breakpoint,
+					browser
+				});
+				fileNameWithExt = `${snapshotShotName}${label}.png`;
+				return {
+					...baseShotItem,
+					id: `${story.id}${label}-${snapshot.name ?? "snapshot"}`,
+					shotName: `${snapshotShotName}${label}`,
+					breakpoint,
+					breakpointGroup: story.id,
+					filePathBaseline: isPlatformModeConfig(config) ? "not supported" : path.join(config.imagePathBaseline, fileNameWithExt),
+					filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+					filePathDifference: isPlatformModeConfig(config) ? "not supported" : path.join(config.imagePathDifference, fileNameWithExt),
+					url: generateStoryUrl(iframeUrl, story.id, combinedArgs, breakpoint),
+					viewport: breakpoint ? {
+						width: breakpoint,
+						height: void 0
+					} : void 0,
+					browserConfig: generateBrowserConfig$1({
+						...story,
+						parameters: {
+							...story.parameters,
+							viewport: { width: breakpoint }
+						}
+					})
+				};
+			});
+		}) ?? [];
+		return [...shotItems, ...extraShots];
+	});
+};
+//#endregion
+//#region src/crawler/pageScreenshots.ts
+const generateBrowserConfig = (page) => {
+	const browserConfig = config.configureBrowser?.({
+		...page,
+		shotMode: "page"
+	});
+	if (page.viewport && browserConfig) {
+		browserConfig.viewport ??= {
+			width: 1280,
+			height: 720
+		};
+		browserConfig.viewport = {
+			...browserConfig.viewport,
+			...page.viewport
+		};
+	}
+	return browserConfig;
+};
+const generatePageShotItems = (pages, baseUrl, mask, modeBreakpoints, browser) => {
+	const names = pages.map((page) => page.name);
+	const uniqueNames = new Set(names);
+	if (names.length !== uniqueNames.size) throw new Error("Error: Page names must be unique");
+	return pages.flatMap((page) => {
+		const shotName = config.shotNameGenerator?.({
+			...page,
+			shotMode: "page"
+		}) ?? page.name;
+		let label = generateLabel({ browser });
+		let fileNameWithExt = `${shotName}${label}.png`;
+		const baseShotItem = {
+			shotMode: "page",
+			id: `${shotName}${label}`,
+			shotName: `${shotName}${label}`,
+			url: path.join(baseUrl, page.path),
+			filePathBaseline: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathBaseline, fileNameWithExt),
+			filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+			filePathDifference: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathDifference, fileNameWithExt),
+			browserConfig: generateBrowserConfig(page),
+			threshold: page.threshold ?? config.threshold,
+			waitBeforeScreenshot: page.waitBeforeScreenshot ?? config.waitBeforeScreenshot,
+			mask: [...mask ?? [], ...page.mask ?? []],
+			waitForSelector: config?.pageShots?.waitForSelector,
+			componentPath: void 0,
+			storyName: void 0
+		};
+		const breakpoints = selectBreakpoints(config.breakpoints, modeBreakpoints, page.breakpoints);
+		if (breakpoints.length === 0) return [baseShotItem];
+		return breakpoints.map((breakpoint) => {
+			label = generateLabel({
+				breakpoint,
+				browser
+			});
+			fileNameWithExt = `${shotName}${label}.png`;
+			return {
+				...baseShotItem,
+				id: `${shotName}${label}`,
+				shotName: `${shotName}${label}`,
+				breakpoint,
+				breakpointGroup: page.name,
+				url: path.join(baseUrl, page.path),
+				filePathBaseline: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathBaseline, fileNameWithExt),
+				filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+				filePathDifference: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathDifference, fileNameWithExt),
+				viewport: { width: breakpoint },
+				browserConfig: generateBrowserConfig({
+					...page,
+					viewport: { width: breakpoint }
+				})
+			};
+		});
+	});
+};
+const isValidHttpUrl = (string) => {
+	let url;
+	try {
+		url = new URL(string);
+	} catch {
+		return false;
+	}
+	return url.protocol === "http:" || url.protocol === "https:";
+};
+const getPagesFromExternalLoader = async () => {
+	try {
+		if (!config.pageShots?.pagesJsonUrl) return [];
+		log.process("info", "general", `⏬ Loading pages from ${config.pageShots.pagesJsonUrl}`);
+		let pages;
+		if (isValidHttpUrl(config.pageShots.pagesJsonUrl)) {
+			log.process("info", "general", `🕸️ Trying to fetch from URL`);
+			pages = (await axios.get(config.pageShots.pagesJsonUrl)).data;
+		} else {
+			log.process("info", "general", `⏬ Trying to fetch from local file`);
+			const fileContents = await fs.readFile(config.pageShots.pagesJsonUrl, "utf8");
+			pages = JSON.parse(fileContents);
+		}
+		const validatePages = z.array(z.object({
+			path: z.string(),
+			name: z.string(),
+			waitBeforeScreenshot: z.number().optional(),
+			threshold: z.number().optional(),
+			mask: z.array(z.object({ selector: z.string() })).optional(),
+			viewport: z.object({
+				width: z.string(),
+				height: z.string()
+			}).optional()
+		})).safeParse(pages);
+		if (validatePages.success) {
+			log.process("info", "general", `✅ Successfully validated pages structure & loaded ${pages.length} pages from JSON file.`);
+			return pages;
+		}
+		log.process("error", "general", "❌ Error validating the loaded pages structure");
+		log.process("error", "general", validatePages.error);
+		return [];
+	} catch (error) {
+		if (isAxiosError(error) || error instanceof Error) log.process("error", "network", `❌ Error when fetching data: ${error.message}`);
+		return [];
+	}
+};
+//#endregion
+//#region src/shots/shots.ts
+const takeScreenShot = async ({ browser, shotItem, logger }) => {
+	const context = await browser.newContext(shotItem.browserConfig);
+	const page = await context.newPage();
+	let success = false;
+	page.on("pageerror", (exception) => {
+		logger.browser("error", "general", "Uncaught exception:", exception);
+	});
+	page.on("console", async (message) => {
+		const values = [];
+		try {
+			for (const arg of message.args()) values.push(await arg.jsonValue());
+		} catch (error) {
+			logger.browser("error", "console", "Error while collecting console output", error);
+		}
+		logger.browser("info", "console", String(values.shift()), ...values);
+	});
+	try {
+		await page.goto(shotItem.url);
+	} catch (error) {
+		if (error instanceof Error && error.name === "TimeoutError") logger.process("error", "timeout", `Timeout while loading page: ${shotItem.url}`);
+		else logger.process("error", "general", "Page loading failed", error);
+	}
+	try {
+		await page.waitForLoadState("load", { timeout: config.timeouts.loadState });
+	} catch (error) {
+		logger.process("error", "timeout", `Timeout while waiting for page load state: ${shotItem.url}`, error);
+	}
+	if (shotItem.waitForSelector) try {
+		await page.waitForSelector(shotItem.waitForSelector, {
+			state: "attached",
+			timeout: config.timeouts.loadState
+		});
+	} catch (error) {
+		logger.process("error", "timeout", `Timeout while waiting for Selector ('${shotItem.waitForSelector}') to appear: ${shotItem.url}`, error);
+	}
+	try {
+		await waitForNetworkRequests({
+			page,
+			logger,
+			ignoreUrls: ["/__webpack_hmr"]
+		});
+	} catch (error) {
+		logger.process("error", "timeout", `Timeout while waiting for all network requests: ${shotItem.url}`, error);
+	}
+	if (config.beforeScreenshot) await config.beforeScreenshot(page, {
+		shotMode: shotItem.shotMode,
+		id: shotItem.id,
+		shotName: shotItem.shotName
+	});
+	let fullScreenMode = true;
+	await sleep(shotItem?.waitBeforeScreenshot ?? config.waitBeforeScreenshot);
+	try {
+		if (shotItem.viewport) {
+			const currentViewport = page.viewportSize();
+			await page.setViewportSize({
+				width: shotItem.viewport.width,
+				height: currentViewport?.height ?? 500
+			});
+			fullScreenMode = true;
+		} else {
+			await resizeViewportToFullscreen({ page });
+			fullScreenMode = false;
+		}
+	} catch (error) {
+		logger.process("error", "general", `Could not resize viewport to fullscreen: ${shotItem.shotName}`, error);
+	}
+	let retryCount = 0;
+	let lastShotHash;
+	try {
+		while (retryCount <= config.flakynessRetries) {
+			const { elementLocator } = shotItem;
+			let screenshotOptions = {
+				path: shotItem.filePathCurrent,
+				animations: "disabled",
+				mask: shotItem.mask ? shotItem.mask.map((mask) => page.locator(mask.selector)) : []
+			};
+			if (elementLocator) await page.locator(elementLocator).screenshot(screenshotOptions);
+			else if (shotItem.shotMode === "storybook") if (await page.evaluate(() => {
+				for (const sel of [
+					"[data-radix-portal]",
+					"[data-radix-popper-content-wrapper]",
+					"[role='dialog']",
+					"[role='alertdialog']",
+					".ReactModal__Overlay"
+				]) {
+					const el = document.querySelector(sel);
+					if (el && el.offsetHeight > 0) return true;
+				}
+				return false;
+			})) {
+				const clip = await page.evaluate(() => {
+					const elements = document.querySelectorAll("#storybook-root, #storybook-root *, [data-radix-portal], [data-radix-portal] *, [role='dialog'], [role='dialog'] *");
+					let minX = Infinity;
+					let minY = Infinity;
+					let maxX = 0;
+					let maxY = 0;
+					for (const el of elements) {
+						const rect = el.getBoundingClientRect();
+						if (rect.width === 0 || rect.height === 0) continue;
+						minX = Math.min(minX, rect.left);
+						minY = Math.min(minY, rect.top);
+						maxX = Math.max(maxX, rect.right);
+						maxY = Math.max(maxY, rect.bottom);
+					}
+					if (minX === Infinity) return null;
+					return {
+						x: Math.max(0, Math.floor(minX)),
+						y: Math.max(0, Math.floor(minY)),
+						width: Math.ceil(maxX - Math.max(0, minX)),
+						height: Math.ceil(maxY - Math.max(0, minY))
+					};
+				});
+				if (clip && clip.width > 0 && clip.height > 0) await page.screenshot({
+					...screenshotOptions,
+					clip
+				});
+				else await page.screenshot({
+					...screenshotOptions,
+					fullPage: fullScreenMode
+				});
+			} else {
+				const storybookRoot = page.locator("#storybook-root");
+				if (await storybookRoot.count() > 0) await storybookRoot.screenshot(screenshotOptions);
+				else await page.screenshot({
+					...screenshotOptions,
+					fullPage: fullScreenMode
+				});
+			}
+			else {
+				screenshotOptions = {
+					...screenshotOptions,
+					fullPage: fullScreenMode
+				};
+				await page.screenshot(screenshotOptions);
+			}
+			const currentShotHash = hashFile(shotItem.filePathCurrent);
+			if (lastShotHash) {
+				logger.process("info", "general", `Screenshot of '${shotItem.shotName}' taken (Retry ${retryCount}). Hash: ${currentShotHash} - Previous hash: ${lastShotHash}`);
+				if (lastShotHash === currentShotHash) break;
+			}
+			lastShotHash = currentShotHash;
+			if (retryCount < config.flakynessRetries) await sleep(config.waitBetweenFlakynessRetries);
+			retryCount++;
+		}
+		success = true;
+		try {
+			const domHtml = await page.content();
+			writeFileSync(shotItem.filePathCurrent.replace(/\.png$/, ".html"), domHtml);
+		} catch (domError) {
+			logger.process("error", "general", "Failed to capture DOM snapshot", domError);
+		}
+	} catch (error) {
+		logger.process("error", "general", "Error when taking screenshot", error);
+	}
+	if (config.afterScreenshot) await config.afterScreenshot(page, shotItem);
+	await context.close();
+	const videoPath = await page.video()?.path();
+	if (videoPath) {
+		const dirname = path.dirname(videoPath);
+		const ext = videoPath.split(".").pop() ?? "webm";
+		const newVideoPath = `${dirname}/${shotItem.shotName}.${ext}`;
+		await page.video()?.saveAs(newVideoPath);
+		await page.video()?.delete();
+		logger.process("info", "general", `Video of '${shotItem.shotName}' recorded and saved to '${newVideoPath}`);
+	}
+	return success;
+};
+const takeScreenShots = async (shotItems, _browser) => {
+	const browser = await launchBrowser(_browser);
+	const total = shotItems.length;
+	await mapLimit(shotItems.entries(), config.shotConcurrency, async (item) => {
+		const [index, shotItem] = item;
+		const logger = log.item({
+			shotMode: shotItem.shotMode,
+			uniqueItemId: shotItem.shotName,
+			itemIndex: index,
+			totalItems: total
+		});
+		logger.process("info", "general", `Taking screenshot of '${shotItem.shotName} ${shotItem.breakpoint ? `[${shotItem.breakpoint}]` : ""}'`);
+		const startTime = Date.now();
+		const result = await takeScreenShot({
+			browser,
+			shotItem,
+			logger
+		});
+		const elapsedTime = Number((Date.now() - startTime) / 1e3).toFixed(3);
+		if (result) logger.process("info", "general", `Screenshot of '${shotItem.shotName}' taken and saved to '${shotItem.filePathCurrent}' in ${elapsedTime}s`);
+		else logger.process("info", "general", `Screenshot of '${shotItem.shotName}' failed and took ${elapsedTime}s`);
+	});
+	await browser.close();
+};
+//#endregion
+//#region src/crawler/utils.ts
+const launchStaticWebServer = async (basePath) => {
+	const port = await getPort({ random: true });
+	const server = http.createServer(async (request, response) => {
+		return handler(request, response, {
+			public: basePath.startsWith("file://") ? basePath.slice(7) : basePath,
+			cleanUrls: false
+		});
+	});
+	server.listen(port);
+	return {
+		server,
+		port,
+		url: `http://localhost:${port}`
+	};
+};
+//#endregion
+//#region src/crawler/histoireScreenshots.ts
+const generateShotItemsForStory = (story, baseUrl, browser) => {
+	const shotItems = [];
+	const variants = story.variants ?? [story];
+	for (const variant of variants) {
+		const shotName = config.shotNameGenerator?.({
+			...variant,
+			shotMode: "histoire"
+		}) ?? `${story.id}_${variant.title}`;
+		const label = generateLabel({ browser });
+		const fileNameWithExt = `${shotName}${label}.png`;
+		shotItems.push({
+			shotMode: "histoire",
+			id: `${story.id}_${variant.id}${label}`,
+			shotName: `${shotName}${label}`,
+			url: `${baseUrl}/__sandbox.html?storyId=${story.id}&variantId=${variant.id}`,
+			filePathBaseline: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathBaseline, fileNameWithExt),
+			filePathCurrent: path.join(config.imagePathCurrent, fileNameWithExt),
+			filePathDifference: isPlatformModeConfig(config) ? notSupported : path.join(config.imagePathDifference, fileNameWithExt),
+			threshold: config.threshold,
+			waitForSelector: config?.histoireShots?.waitForSelector,
+			componentPath: story.id,
+			storyName: variant.title
+		});
+	}
+	return shotItems.filter((story) => story.id !== "full-config");
+};
+const generateHistoireShotItems = (baseUrl, stories, browser) => {
+	return stories.flatMap((story) => generateShotItemsForStory(story, baseUrl, browser));
+};
+const collectHistoireStories = async (histoireUrl) => {
+	const jsonUrl = `${histoireUrl}/histoire.json`;
+	log.process("info", "general", `\n=== [Histoire Mode] ${jsonUrl} ===\n`);
+	return (await axios.get(jsonUrl)).data.stories;
+};
+//#endregion
+//#region src/createShots.ts
+const createShots = async () => {
+	const { ladleShots, histoireShots, storybookShots, pageShots, customShots, imagePathCurrent } = config;
+	let storybookShotItems = [];
+	let ladleShotItems = [];
+	let histoireShotItems = [];
+	let pageShotItems = [];
+	let customShotItems = [];
+	removeFilesInFolder(imagePathCurrent);
+	if (!isPlatformModeConfig(config)) removeFilesInFolder(config.imagePathDifference);
+	const browsers = getBrowsers();
+	if (ladleShots) {
+		const { ladleUrl, mask } = ladleShots;
+		log.process("info", "general", `\n=== [Ladle Mode] ${ladleUrl} ===\n`);
+		let ladleWebUrl = ladleUrl;
+		let localServer;
+		if (!ladleUrl.startsWith("http://") && !ladleUrl.startsWith("https://")) {
+			const staticWebServer = await launchStaticWebServer(ladleUrl);
+			ladleWebUrl = staticWebServer.url;
+			localServer = staticWebServer.server;
+		}
+		try {
+			const collection = await collectLadleStories(ladleWebUrl);
+			if (!collection || collection.length === 0) throw new Error("Error: Stories not found");
+			log.process("info", "general", `Found ${collection.length} ladle stories`);
+			await mapLimit(browsers, 1, async (browser) => {
+				const shotItems = generateLadleShotItems(ladleWebUrl, Boolean(localServer), collection, mask, ladleShots.breakpoints, browsers.length > 1 ? browser : void 0);
+				const filterItemsToCheck = "filterItemsToCheck" in config ? config.filterItemsToCheck : void 0;
+				const filteredShotItems = filterItemsToCheck ? shotItems.filter((item) => filterItemsToCheck(item)) : shotItems;
+				ladleShotItems = shotItems;
+				log.process("info", "general", `Prepared ${filteredShotItems.length} ladle stories for screenshots on ${browser.name()}`);
+				await takeScreenShots(filteredShotItems, browser);
+			});
+			localServer?.close();
+		} catch (error) {
+			localServer?.close();
+			throw error;
+		}
+		log.process("info", "general", "Screenshots done!");
+	}
+	if (histoireShots) {
+		const { histoireUrl } = histoireShots;
+		let localServer;
+		let histoireWebUrl;
+		if (!histoireUrl.startsWith("http://") && !histoireUrl.startsWith("https://")) {
+			const staticWebServer = await launchStaticWebServer(histoireUrl);
+			histoireWebUrl = staticWebServer.url;
+			localServer = staticWebServer.server;
+		}
+		if (!histoireWebUrl) throw new Error("Error: Histoire web url not found");
+		log.process("info", "general", `\n=== [Histoire Mode] ${histoireUrl} ===\n`);
+		try {
+			const collection = await collectHistoireStories(histoireWebUrl);
+			if (!collection || collection.length === 0) throw new Error("Error: Stories not found");
+			log.process("info", "general", `Found ${collection.length} Histoire stories`);
+			await mapLimit(browsers, 1, async (browser) => {
+				const shotItems = generateHistoireShotItems(histoireWebUrl, collection, browsers.length > 1 ? browser : void 0);
+				histoireShotItems = shotItems;
+				log.process("info", "general", `Prepared ${shotItems.length} Histoire stories for screenshots on ${browser.name()}`);
+				await takeScreenShots(shotItems, browser);
+			});
+			localServer?.close();
+		} catch (error) {
+			localServer?.close();
+			throw error;
+		}
+		log.process("info", "general", "Screenshots done!");
+	}
+	if (storybookShots) {
+		const { storybookUrl, mask } = storybookShots;
+		log.process("info", "general", `\n=== [Storybook Mode] ${storybookUrl} ===\n`);
+		let storybookWebUrl = storybookUrl;
+		let localServer;
+		if (!storybookUrl.startsWith("http://") && !storybookUrl.startsWith("https://")) {
+			const staticWebServer = await launchStaticWebServer(storybookUrl);
+			storybookWebUrl = staticWebServer.url;
+			localServer = staticWebServer.server;
+		}
+		try {
+			const collection = await collectStories(storybookWebUrl);
+			if (!collection?.stories || collection.stories.length === 0) throw new Error("Error: Stories not found");
+			log.process("info", "general", `Found ${collection.stories.length} stories`);
+			await mapLimit(browsers, 1, async (browser) => {
+				const shotItems = generateStorybookShotItems(storybookWebUrl, collection.stories, mask, storybookShots.breakpoints, browsers.length > 1 ? browser : void 0);
+				const filterItemsToCheck = "filterItemsToCheck" in config ? config.filterItemsToCheck : void 0;
+				const filteredShotItems = filterItemsToCheck ? shotItems.filter((item) => filterItemsToCheck(item)) : shotItems;
+				storybookShotItems = shotItems;
+				log.process("info", "general", `Prepared ${filteredShotItems.length} stories for screenshots on ${browser.name()}`);
+				await takeScreenShots(filteredShotItems, browser);
+			});
+			localServer?.close();
+		} catch (error) {
+			localServer?.close();
+			throw error;
+		}
+		log.process("info", "general", "Screenshots done!");
+	}
+	if (pageShots) {
+		const { pages: pagesFromConfig, baseUrl, mask, breakpoints } = pageShots;
+		const pagesFromLoader = await getPagesFromExternalLoader();
+		let jsonPages = pagesFromLoader || [];
+		if (config.pageShots?.pagesJsonRefiner) {
+			log.process("info", "general", `🧬 Refining pages received in json with function provided in pagesJsonRefiner`);
+			jsonPages = config.pageShots.pagesJsonRefiner(pagesFromLoader || []);
+		}
+		if (jsonPages.length > 0) log.process("info", "general", `Found ${jsonPages.length} pages from external loader`);
+		const pages = [...pagesFromConfig || [], ...jsonPages || []];
+		log.process("info", "general", `\n=== [Page Mode] ${baseUrl} ===\n`);
+		await mapLimit(browsers, 1, async (browser) => {
+			const shotItems = generatePageShotItems(pages, baseUrl, mask, breakpoints, browsers.length > 1 ? browser : void 0);
+			pageShotItems = shotItems;
+			log.process("info", "general", `Prepared ${shotItems.length} pages for screenshots on ${browser.name()}`);
+			await takeScreenShots(shotItems, browser);
+		});
+		log.process("info", "general", "Screenshots done!");
+	}
+	if (customShots) {
+		const { currentShotsPath } = customShots;
+		log.process("info", "general", `\n=== [Custom Mode] ${currentShotsPath} ===\n`);
+		customShotItems = readDirIntoShotItems(currentShotsPath);
+		log.process("info", "general", `Found ${customShotItems.length} custom shots`);
+	}
+	return [
+		...storybookShotItems,
+		...pageShotItems,
+		...ladleShotItems,
+		...histoireShotItems,
+		...customShotItems
+	];
+};
+//#endregion
+//#region ../shared/dist/client.js
+/**
+* Typed oRPC client factory.
+* Used by CLI and frontend to create a type-safe client.
+*
+* Uses RPCLink which speaks the oRPC RPC wire format.
+* The server mounts both OpenAPIHandler (for .route()-defined REST endpoints)
+* and RPCHandler (fallback for all procedures). The RPCLink client always
+* hits the RPCHandler path, ensuring compatibility during the OpenAPI migration.
+*/
+const resolveBaseUrl = (url) => {
+	if (url.startsWith("http")) return url;
+	if (typeof window !== "undefined") return `${window.location.origin}${url}`;
+	return url;
+};
+const isBrowser = typeof window !== "undefined";
+const createTypedClient = (options) => {
+	return createORPCClient(new RPCLink({
+		url: () => `${resolveBaseUrl(options.url)}/rpc`,
+		fetch: (input, init) => fetch(input, {
+			...init,
+			...isBrowser ? { credentials: "include" } : {}
+		}),
+		headers: () => {
+			const headers = {};
+			if (options.apiToken) headers.authorization = `Bearer ${options.apiToken}`;
+			if (options.apiKey) headers["x-api-key"] = options.apiKey;
+			return headers;
+		}
+	}));
+};
+//#endregion
+//#region src/api.ts
+const createClient = (platformUrl, apiKey, apiToken) => createTypedClient({
+	url: platformUrl,
+	apiKey,
+	apiToken
+});
+const withRetry = async (action, fn, logger = log.process) => {
+	logger("info", "api", `Sending to API [${action}]`);
+	const result = await retry({
+		times: 3,
+		interval(retryCount) {
+			const delay = Math.round(2 ** retryCount * 3e3 * Math.random());
+			logger("info", "api", `Retry attempt ${retryCount} in ${delay}ms [${action}]`);
+			return delay;
+		}
+	}, async () => fn());
+	logger("info", "api", `Successfully sent to API [${action}]`);
+	return result;
+};
+const getApiToken = async (config) => {
+	const client = createClient(config.thirdEyePlatform, config.apiKey);
+	try {
+		return await withRetry("getApiToken", () => client.auth.getApiToken({
+			projectId: config.thirdEyeProjectId,
+			orgId: config.thirdEyeOrgId
+		}));
+	} catch (error) {
+		if (error instanceof Error) log.process("error", "api", error.message);
+		else log.process("error", "api", error);
+		process.exit(1);
+	}
+};
+const sendInitToAPI = async (config, apiToken) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	return withRetry("init", () => client.orgs.projects.builds.init({
+		orgId: config.thirdEyeOrgId,
+		projectId: config.thirdEyeProjectId,
+		commit: config.commitHash,
+		branchName: config.commitRefName,
+		buildNumber: config.ciBuildNumber,
+		baseBranch: config.baseBranch || void 0,
+		prNumber: config.prNumber
+	}));
+};
+const sendFinalizeToAPI = async (config, apiToken) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	return withRetry("finalize", () => client.orgs.projects.builds.finalize({
+		orgId: config.thirdEyeOrgId,
+		projectId: config.thirdEyeProjectId,
+		branchName: config.commitRefName,
+		commit: config.commitHash,
+		buildNumber: config.ciBuildNumber
+	}));
+};
+const sendCheckCacheToAPI = async (config, apiToken, cacheKey) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	return withRetry("checkCache", () => client.orgs.projects.builds.checkCache({
+		orgId: config.thirdEyeOrgId,
+		projectId: config.thirdEyeProjectId,
+		cacheKey
+	}));
+};
+const prepareUpload = async (config, apiToken, shotNamesWithHashes, cacheKey) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	return withRetry("prepareUpload", () => client.orgs.projects.uploads.prepare({
+		orgId: config.thirdEyeOrgId,
+		projectId: config.thirdEyeProjectId,
+		branchName: config.commitRefName,
+		commit: config.commitHash,
+		buildNumber: config.ciBuildNumber,
+		currentShots: shotNamesWithHashes,
+		cacheKey
+	}));
+};
+const uploadShot = async ({ config, apiToken, uploadToken, name, file, shotMode, componentPath, storyName, storyId, importPath, metadata, logger }) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	const logFn = logger?.process ?? log.process;
+	const fileData = readFileSync(file).toString("base64");
+	return withRetry("uploadShot", () => client.orgs.projects.uploads.uploadShot({
+		orgId: config.thirdEyeOrgId,
+		uploadToken,
+		name,
+		fileData,
+		shotMode,
+		componentPath,
+		storyName,
+		storyId,
+		importPath,
+		metadata
+	}), logFn);
+};
+const processShots = async (config, apiToken, uploadToken, shotsConfig, cacheKey) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	return withRetry("processShots", () => client.orgs.projects.builds.processShots({
+		orgId: config.thirdEyeOrgId,
+		uploadToken,
+		config: {
+			shots: shotsConfig,
+			threshold: config.threshold
+		},
+		log: logMemory,
+		cacheKey
+	}));
+};
+const sendRecordLogsToAPI = async (_config, _apiToken) => {
+	log.process("info", "api", "Logs recorded with build");
+};
+const getAffectedStories = async (config, apiToken, changedFiles) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	return withRetry("getAffectedStories", () => client.orgs.projects.builds.getAffectedStories({
+		orgId: config.thirdEyeOrgId,
+		projectId: config.thirdEyeProjectId,
+		changedFiles
+	}));
+};
+const uploadStorybookArchive = async (config, apiToken, projectId, buildId, archive) => {
+	const client = createClient(config.thirdEyePlatform, void 0, apiToken);
+	return withRetry("uploadStorybookArchive", () => client.orgs.projects.storybook.uploadArchive({
+		orgId: config.thirdEyeOrgId,
+		projectId,
+		buildId,
+		archive
+	}));
+};
+//#endregion
+//#region src/upload.ts
+const uploadRequiredShots = async ({ config, apiToken, uploadToken, requiredFileHashes, extendedShotItems }) => {
+	if (requiredFileHashes.length > 0) {
+		log.process("info", "api", "Uploading shots");
+		const uploadStart = process.hrtime();
+		const requiredShotItems = extendedShotItems.filter((shotItem) => requiredFileHashes.includes(shotItem.hash));
+		await mapLimit(requiredShotItems.entries(), 10, async ([index, shotItem]) => {
+			const logger = log.item({
+				shotMode: shotItem.shotMode,
+				uniqueItemId: shotItem.shotName,
+				itemIndex: index,
+				totalItems: requiredShotItems.length
+			});
+			const htmlPath = shotItem.filePathCurrent.replace(/\.png$/, ".html");
+			const domHtml = existsSync(htmlPath) ? readFileSync(htmlPath).toString("base64") : void 0;
+			await uploadShot({
+				config,
+				apiToken,
+				uploadToken,
+				name: `${shotItem.shotMode}/${shotItem.shotName}`,
+				file: shotItem.filePathCurrent,
+				shotMode: shotItem.shotMode,
+				componentPath: shotItem.componentPath,
+				storyName: shotItem.storyName,
+				storyId: shotItem.storyId,
+				importPath: shotItem.importPath,
+				metadata: {
+					...shotItem.storyArgs ? { args: shotItem.storyArgs } : {},
+					...shotItem.tags ? { tags: shotItem.tags } : {},
+					...shotItem.viewport ? { viewport: shotItem.viewport } : {},
+					...shotItem.breakpoint !== void 0 ? { breakpoint: shotItem.breakpoint } : {},
+					...domHtml ? { dom_html: domHtml } : {}
+				},
+				logger
+			});
+		});
+		const uploadStop = process.hrtime(uploadStart);
+		log.process("info", "api", `Uploading shots took ${parseHrtimeToSeconds(uploadStop)} seconds`);
+	}
+	return true;
+};
+//#endregion
+//#region src/runner.ts
+/**
+* Get the list of files changed between the current HEAD and a base ref
+* using git diff. Returns an empty array if git is unavailable or fails.
+*/
+const getChangedFiles = (baseRef) => {
+	try {
+		return execSync(`git diff --name-only ${baseRef}...HEAD`, {
+			encoding: "utf-8",
+			timeout: 3e4
+		}).trim().split("\n").filter((f) => f.length > 0);
+	} catch (error) {
+		if (error instanceof Error) log.process("warn", "general", `Failed to get changed files: ${error.message}`);
+		return [];
+	}
+};
+const runner = async (config) => {
+	const executionStart = process.hrtime();
+	try {
+		if (isUpdateMode()) log.process("info", "general", "Running third-eye in update mode. Baseline screenshots will be updated");
+		log.process("info", "general", "📂 Creating shot folders");
+		const createShotsStart = process.hrtime();
+		createShotsFolders();
+		log.process("info", "general", "📸 Creating shots");
+		const shotItems = await createShots();
+		const createShotsStop = process.hrtime(createShotsStart);
+		log.process("info", "general", `Creating shots took ${parseHrtimeToSeconds(createShotsStop)} seconds`);
+		if (config.generateOnly && shotItems.length === 0) {
+			log.process("info", "general", `👋 Exiting process with nothing to compare.`);
+			await exitProcess({ shotsNumber: shotItems.length });
+		}
+		log.process("info", "general", "🔍 Checking differences");
+		const checkDifferenceStart = process.hrtime();
+		const { filterItemsToCheck } = config;
+		const { aboveThresholdDifferenceItems, noBaselinesItems } = await checkDifferences(filterItemsToCheck ? shotItems.filter((item) => filterItemsToCheck(item)) : shotItems);
+		if (isUpdateMode()) {
+			removeFilesInFolder(config.imagePathBaseline, shotItems.map((shotItem) => shotItem.filePathBaseline));
+			for (const noBaselineItem of noBaselinesItems) fs.copySync(noBaselineItem.filePathCurrent, noBaselineItem.filePathBaseline);
+			for (const aboveThresholdDifferenceItem of aboveThresholdDifferenceItems) fs.copySync(aboveThresholdDifferenceItem.filePathCurrent, aboveThresholdDifferenceItem.filePathBaseline);
+		}
+		if ((aboveThresholdDifferenceItems.length > 0 || noBaselinesItems.length > 0) && config.failOnDifference) {
+			log.process("info", "general", `👋 Exiting process with ${aboveThresholdDifferenceItems.length} found differences & ${noBaselinesItems.length} baselines to update`);
+			if (config.generateOnly) await exitProcess({ shotsNumber: shotItems.length });
+		}
+		const checkDifferenceStop = process.hrtime(checkDifferenceStart);
+		log.process("info", "general", `⏱  Checking differences took ${parseHrtimeToSeconds(checkDifferenceStop)} seconds`);
+		const executionStop = process.hrtime(executionStart);
+		log.process("info", "general", `⏱  Lost Pixel run took ${parseHrtimeToSeconds(executionStop)} seconds`);
+		await exitProcess({
+			shotsNumber: shotItems.length,
+			runDuration: Number(parseHrtimeToSeconds(executionStop)),
+			exitCode: 0
+		});
+	} catch (error) {
+		const executionStop = process.hrtime(executionStart);
+		if (error instanceof Error) log.process("error", "general", error.message);
+		else log.process("error", "general", error);
+		await exitProcess({
+			runDuration: Number(parseHrtimeToSeconds(executionStop)),
+			error
+		});
+	}
+};
+const getPlatformApiToken = async (config) => {
+	if (!config.apiKey) {
+		log.process("error", "general", `Running Lost Pixel in 'platform' mode requires an API key`);
+		process.exit(1);
+	}
+	if (isUpdateMode()) {
+		log.process("error", "general", `Running Lost Pixel in 'update' mode requires the 'generateOnly' option to be set to true`);
+		process.exit(1);
+	}
+	try {
+		return (await getApiToken(config)).apiToken;
+	} catch (error) {
+		if (error instanceof Error) log.process("error", "general", error.message);
+		else log.process("error", "general", error);
+		process.exit(1);
+	}
+};
+const checkForCachedBuild = async (config, apiToken) => {
+	if (process.env.THIRD_EYE_CACHE_KEY) {
+		log.process("info", "general", `♻️  Using cache key ${process.env.THIRD_EYE_CACHE_KEY}`);
+		const { cacheExists } = await sendCheckCacheToAPI(config, apiToken, process.env.THIRD_EYE_CACHE_KEY);
+		if (cacheExists) {
+			log.process("info", "general", `♻️  Cache hit for key ${process.env.THIRD_EYE_CACHE_KEY} - Skipping shot creation`);
+			const { uploadToken } = await prepareUpload(config, apiToken, [], process.env.THIRD_EYE_CACHE_KEY);
+			await processShots(config, apiToken, uploadToken, [], process.env.THIRD_EYE_CACHE_KEY);
+			return true;
+		}
+		log.process("info", "general", `♻️  Cache miss for key ${process.env.THIRD_EYE_CACHE_KEY}`);
+	}
+	return false;
+};
+const platformRunner = async (config, apiToken) => {
+	const executionStart = process.hrtime();
+	try {
+		log.process("info", "general", [
+			"📀 Using details:",
+			`ciBuildId = ${config.ciBuildId}`,
+			`ciBuildNumber = ${config.ciBuildNumber}`,
+			`repository = ${config.repository}`,
+			`commitRefName = ${config.commitRefName}`,
+			`commitHash = ${config.commitHash}`
+		].join("\n   - "));
+		await sendInitToAPI(config, apiToken);
+		if (!await checkForCachedBuild(config, apiToken)) {
+			log.process("info", "general", "📂 Creating shot folders");
+			const createShotsStart = process.hrtime();
+			createShotsFolders();
+			log.process("info", "general", "📸 Creating shots");
+			let shotItems = await createShots();
+			if (config.turboSnap && config.baseBranch) {
+				log.process("info", "general", `⚡ TurboSnap enabled, checking changed files against ${config.baseBranch}`);
+				const changedFiles = getChangedFiles(config.baseBranch);
+				if (changedFiles.length > 0) {
+					log.process("info", "general", `Found ${changedFiles.length} changed file(s)`);
+					try {
+						const turboResult = await getAffectedStories(config, apiToken, changedFiles);
+						log.process("info", "general", `TurboSnap: ${turboResult.affectedCount} affected, ${turboResult.skippedCount} skipped`);
+						if (turboResult.affected.length > 0) {
+							const affectedSet = new Set(turboResult.affected);
+							shotItems = shotItems.filter((item) => affectedSet.has(item.shotName) || affectedSet.has(`${item.shotMode}/${item.shotName}`));
+						}
+					} catch (error) {
+						if (error instanceof Error) log.process("warn", "general", `TurboSnap filtering failed, capturing all stories: ${error.message}`);
+					}
+				} else log.process("info", "general", "TurboSnap: no changed files detected, capturing all stories");
+			}
+			const shotNames = shotItems.map((shotItem) => shotItem.shotName);
+			const uniqueShotNames = new Set(shotNames);
+			if (shotNames.length !== uniqueShotNames.size) {
+				const duplicates = shotNames.filter((shotName) => shotNames.filter((item) => item === shotName).length > 1);
+				throw new Error(`Error: Shot names must be unique (check for duplicate Story names: [ ${[...new Set(duplicates)].join(", ")} ])`);
+			}
+			const createShotsStop = process.hrtime(createShotsStart);
+			log.process("info", "general", `⏱  Creating shots took ${parseHrtimeToSeconds(createShotsStop)} seconds`);
+			const extendedShotItems = shotItems.map((shotItem) => ({
+				...shotItem,
+				uniqueName: `${shotItem.shotMode}/${shotItem.shotName}`,
+				hash: hashFile(shotItem.filePathCurrent)
+			}));
+			const { buildId, requiredFileHashes, uploadToken } = await prepareUpload(config, apiToken, extendedShotItems.map((shotItem) => ({
+				name: shotItem.uniqueName,
+				hash: shotItem.hash,
+				storyId: shotItem.storyId
+			})));
+			log.process("info", "general", [
+				`🏙 `,
+				`${shotItems.length} shot(s) in total.`,
+				`${shotItems.length - requiredFileHashes.length} shot(s) already exist on platform.`,
+				`${requiredFileHashes.length} shot(s) will be uploaded.`
+			].join(" "));
+			await uploadRequiredShots({
+				config,
+				apiToken,
+				uploadToken,
+				requiredFileHashes,
+				extendedShotItems
+			});
+			await processShots(config, apiToken, uploadToken, shotItems.map((shotItem) => ({
+				name: `${shotItem.shotMode}/${shotItem.shotName}`,
+				threshold: shotItem.threshold
+			})), process.env.THIRD_EYE_CACHE_KEY);
+			if (config.storybookStaticDir && existsSync(config.storybookStaticDir)) {
+				log.process("info", "general", "Uploading Storybook archive...");
+				const archive = execSync(`tar -czf - -C ${JSON.stringify(config.storybookStaticDir)} .`, { maxBuffer: 50 * 1024 * 1024 }).toString("base64");
+				const result = await uploadStorybookArchive(config, apiToken, config.thirdEyeProjectId, buildId, archive);
+				log.process("info", "general", `Storybook uploaded (${result.fileCount} files, ${Math.round(result.totalSizeBytes / 1024)} KB)`);
+				log.process("info", "general", `Storybook URL: ${result.url}`);
+			}
+		}
+		const executionStop = process.hrtime(executionStart);
+		log.process("info", "general", `⏱  Lost Pixel run took ${parseHrtimeToSeconds(executionStop)} seconds`);
+	} catch (error) {
+		if (error instanceof Error) log.process("error", "general", error.message);
+		else log.process("error", "general", error);
+		log.process("info", "general", "🪵  Sending logs to platform.");
+		await sendRecordLogsToAPI(config, apiToken);
+		process.exit(1);
+	}
+};
+//#endregion
+//#region src/docker-runner/utils.ts
+const executeDockerRun = async ({ version }) => {
+	const isUpdateModeEnabled = isUpdateMode();
+	const isGenerateMetaEnabled = shallGenerateMeta();
+	const isLocalDebugModeEnabled = isLocalDebugMode();
+	const argv = yargs(hideBin(process.argv)).parseSync();
+	return execa("docker", [
+		"run",
+		"--rm",
+		`-v ${process.cwd()}:${process.cwd()}`,
+		`-e WORKSPACE=${process.cwd()}`,
+		"-e DOCKER=1",
+		`-e THIRD_EYE_DISABLE_TELEMETRY=${process.env.THIRD_EYE_DISABLE_TELEMETRY}`,
+		argv.configDir ? `-e THIRD_EYE_CONFIG_DIR=${argv.configDir}` : "",
+		isUpdateModeEnabled ? "-e THIRD_EYE_MODE=update" : "",
+		isGenerateMetaEnabled ? "-e THIRD_EYE_GENERATE_META=true" : "",
+		isLocalDebugModeEnabled ? "-e THIRD_EYE_LOCAL=true" : "",
+		`thirdeye/third-eye:v${version}`
+	], {
+		shell: true,
+		stdio: "inherit"
+	});
+};
+//#endregion
+//#region src/docker-runner/index.ts
+const runInDocker = async () => {
+	const version = getVersion();
+	if (version) {
+		log.process("info", "general", `Running in docker: third-eye:${version}`);
+		try {
+			await executeDockerRun({ version });
+		} catch (error) {
+			log.process("error", "general", error);
+		}
+	} else log.process("error", "config", "Seems like third-eye is missing in your package.json. Running third-eye@latest");
+};
+//#endregion
+//#region src/generatePagesFromSitemap.ts
+async function fetchSitemap(url) {
+	if (url.startsWith("http")) return (await axios.get(url)).data;
+	return readFileSync(url, "utf8");
+}
+async function parseSitemap(sitemapContent) {
+	const result = new XMLParser({ isArray: (_tagName, jPath) => typeof jPath === "string" && (jPath === "urlset.url" || jPath === "urlset.url.loc" || jPath === "urlset.url.lastmod") }).parse(sitemapContent);
+	if (!result.urlset || !Array.isArray(result.urlset.url)) throw new Error("Invalid sitemap format");
+	return result.urlset.url.filter((urlEntry) => urlEntry.loc && urlEntry.loc.length > 0).map((urlEntry) => urlEntry.loc[0]);
+}
+async function generatePagesFileFromSitemap(url, options) {
+	try {
+		const pages = (await parseSitemap(await fetchSitemap(url))).map((url) => {
+			return PageScreenshotParameterSchema.parse({
+				path: new URL(url).pathname,
+				name: url.replace(/^https?:\/\/(www\.)?|^www\./g, "").replace(/\//g, "_")
+			});
+		});
+		writeFileSync(options.outputPath, JSON.stringify(pages, null, 2));
+		log.process("info", "general", "✅ Pages file generated successfully at", options.outputPath);
+	} catch (error) {
+		log.process("error", "general", "❌ Pages file generation errored out. Please check the error message below", error);
+	}
+}
+const generatePagesFromSitemap = async () => {
+	const { sitemapUrl, outputPath } = await yargs(hideBin(process.argv)).usage("Usage: $0 <command> <sitemapUrl> <outputPath>").command("page-sitemap-gen <sitemapUrl> <outputPath>", "Generate pages file from sitemap").demandCommand(1).argv;
+	if (!sitemapUrl || typeof sitemapUrl !== "string" || !outputPath || typeof outputPath !== "string") {
+		log.process("error", "general", "❌ sitemapUrl and outputPath are required");
+		return;
+	}
+	log.process("info", "general", `🧬 Running third-eye in sitemap-page-gen mode. Pages file will be generated from provided sitemap on ${sitemapUrl}`);
+	await generatePagesFileFromSitemap(sitemapUrl, { outputPath });
+};
+//#endregion
+//#region src/bin.ts
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const commandArgs = yargs(hideBin(process.argv)).parseSync()._;
+const version = getVersion();
+if (version) log.process("info", "general", `Version: ${version}`);
+(async () => {
+	if (isSitemapPageGenMode()) {
+		await generatePagesFromSitemap();
+		return;
+	}
+	if (isDockerMode()) await runInDocker();
+	else if (commandArgs.includes("init-js")) {
+		log.process("info", "general", "Initializing javascript third-eye config");
+		await fs.copy(path.join(__dirname, "..", "config-templates", "example.thirdeye.config.js"), path.join(process.cwd(), "./thirdeye.config.js"));
+		log.process("info", "general", "✅ Config successfully initialized");
+	} else if (commandArgs.includes("init-ts")) {
+		log.process("info", "general", "Initializing typescript third-eye config");
+		const modifiedFile = fs.readFileSync(path.join(__dirname, "..", "config-templates", "example.thirdeye.config.ts")).toString().replace("../src/config", "third-eye");
+		fs.writeFileSync(path.join(process.cwd(), "./thirdeye.config.ts"), modifiedFile);
+		log.process("info", "general", "✅ Config successfully initialized");
+	} else {
+		if (process.env.GITHUB_EVENT_PATH && !process.env.THIRD_EYE_PR_NUMBER) try {
+			const event = JSON.parse(readFileSync(process.env.GITHUB_EVENT_PATH, "utf-8"));
+			const prNumber = event.pull_request?.number ?? event.number;
+			if (prNumber) process.env.THIRD_EYE_PR_NUMBER = String(prNumber);
+		} catch {}
+		await configure({ localDebugMode: isLocalDebugMode() });
+		if (isPlatformModeConfig(config)) {
+			log.process("info", "general", `🚀 Starting Lost Pixel in 'platform' mode`);
+			const apiToken = await getPlatformApiToken(config);
+			if (commandArgs.includes("finalize")) await sendFinalizeToAPI(config, apiToken);
+			else await platformRunner(config, apiToken);
+		} else {
+			log.process("info", "general", `🚀 Starting Lost Pixel in 'generateOnly' mode`);
+			await runner(config);
+		}
+	}
+})();
+//#endregion
+export {};
+
+//# sourceMappingURL=bin.mjs.map