@01.works/visual-review 0.1.0

package/dist/next-config.js

@@ -0,0 +1,406 @@
+import { t as resolveVisualReviewBuildIdentity } from "./build-identity-CgoY3-jy.js";
+import { a as visualReviewSourceIndexFilename, c as writeNextVisualReviewSourceIndex, d as uploadNextSourceMaps, i as nextSourceIndexUrl, u as cleanupNextSourceMapOutput } from "./source-index-BdWeiNHZ.js";
+import { randomBytes } from "node:crypto";
+import { dirname, join, resolve } from "node:path";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+//#region src/next-config.ts
+const BUILD_ID_LITERAL = "VISUAL_REVIEW_PUBLIC_BUILD_ID";
+const GIT_COMMIT_LITERAL = "VISUAL_REVIEW_PUBLIC_GIT_COMMIT";
+const BUILD_MODE_LITERAL = "VISUAL_REVIEW_PUBLIC_BUILD_MODE";
+const NEXT_BUILD_IDENTITY_RECORD = "VISUAL_REVIEW_INTERNAL_NEXT_BUILD_IDENTITY";
+const NEXT_MARKER_SALT_PATH = "VISUAL_REVIEW_INTERNAL_NEXT_MARKER_SALT_PATH";
+const FULL_GIT_COMMIT = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u;
+const PUBLIC_BUILD_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const DEPLOYMENT_VARIANT = /^[0-9a-f]{32}$/u;
+const GIT_FALLBACK_BUILD_ID = /^(git:([0-9a-f]{40}|[0-9a-f]{64}):deploy:([0-9a-f]{32}))$/u;
+const MAX_NEXT_BUILD_IDENTITY_RECORD_BYTES = 512;
+const trackedMarkerSaltPaths = /* @__PURE__ */ new Set();
+const VISUAL_REVIEW_HOOK = Symbol.for("01works.visual-review.next-source-map-hook");
+const VISUAL_REVIEW_CONFIG = Symbol.for("01works.visual-review.next-config");
+/**
+* Next evaluates next.config again in compiler workers. A Git fallback contains
+* a per-build public nonce, so recomputing it in each process would make the
+* browser literal disagree with the main process upload hook. Next 15/16 copy
+* the main process environment into those workers; hand off only the already
+* public identity and validate it before reuse. Marker salts and upload tokens
+* are deliberately outside this record.
+*/
+function resolveNextVisualReviewBuildIdentity(options, env) {
+	const privateBuildWorker = env.NEXT_PRIVATE_BUILD_WORKER === "1";
+	const nextWorker = env.IS_NEXT_WORKER === "true";
+	if (!privateBuildWorker && !nextWorker) {
+		delete env[NEXT_BUILD_IDENTITY_RECORD];
+		const identity = resolveVisualReviewBuildIdentity(options, {
+			cwd: process.cwd(),
+			env,
+			createDeploymentVariant: () => randomBytes(16).toString("hex")
+		});
+		const serializedRecord = JSON.stringify({
+			schemaVersion: 1,
+			buildId: identity.buildId,
+			gitCommit: identity.gitCommit
+		});
+		const record = parseNextBuildIdentityRecord(serializedRecord);
+		env[NEXT_BUILD_IDENTITY_RECORD] = serializedRecord;
+		return {
+			buildId: record.buildId,
+			gitCommit: record.gitCommit
+		};
+	}
+	if (!privateBuildWorker || !nextWorker) throw new Error("Visual Review Next.js build worker identity context is invalid");
+	const record = parseNextBuildIdentityRecord(env[NEXT_BUILD_IDENTITY_RECORD]);
+	const fallbackMatch = GIT_FALLBACK_BUILD_ID.exec(record.buildId);
+	const expected = resolveVisualReviewBuildIdentity(options, {
+		cwd: process.cwd(),
+		env,
+		runGit: (arguments_) => {
+			if (arguments_[0] === "status") return record.gitCommit === null ? " M .next/visual-review-build-output" : "";
+			if (arguments_[0] === "rev-parse" && record.gitCommit !== null) return record.gitCommit;
+			throw new Error("Visual Review Next.js worker cannot rediscover Git identity");
+		},
+		createDeploymentVariant: () => fallbackMatch?.[3] ?? "0".repeat(32)
+	});
+	if (expected.buildId !== record.buildId || expected.gitCommit !== record.gitCommit) throw new Error("Visual Review Next.js build worker identity does not match the main build");
+	return {
+		buildId: record.buildId,
+		gitCommit: record.gitCommit
+	};
+}
+function parseNextBuildIdentityRecord(value) {
+	if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value) > MAX_NEXT_BUILD_IDENTITY_RECORD_BYTES) throw new Error("Visual Review Next.js build worker identity is missing or invalid");
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		throw new Error("Visual Review Next.js build worker identity is missing or invalid");
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Visual Review Next.js build worker identity is missing or invalid");
+	const record = parsed;
+	if (Object.keys(record).sort().join(",") !== "buildId,gitCommit,schemaVersion" || record.schemaVersion !== 1 || typeof record.buildId !== "string" || !PUBLIC_BUILD_ID.test(record.buildId) || record.gitCommit !== null && (typeof record.gitCommit !== "string" || !FULL_GIT_COMMIT.test(record.gitCommit))) throw new Error("Visual Review Next.js build worker identity is missing or invalid");
+	const fallbackMatch = GIT_FALLBACK_BUILD_ID.exec(record.buildId);
+	if (/^git:(?:[0-9a-f]{40}|[0-9a-f]{64}):deploy:/u.test(record.buildId) && !fallbackMatch) throw new Error("Visual Review Next.js build worker identity is missing or invalid");
+	if (fallbackMatch && (!DEPLOYMENT_VARIANT.test(fallbackMatch[3] ?? "") || fallbackMatch[2] !== record.gitCommit)) throw new Error("Visual Review Next.js build worker identity is missing or invalid");
+	return {
+		schemaVersion: 1,
+		buildId: record.buildId,
+		gitCommit: record.gitCommit
+	};
+}
+function withVisualReview(nextConfig = {}, options = {}) {
+	const identity = resolveNextVisualReviewBuildIdentity(options, process.env);
+	const sourceMapUpload = resolveSourceMapUpload(options.sourceMaps, process.env);
+	const sourceMetadataEnabled = options.sourceMetadata ?? true;
+	const sourceMarkerSalt = sourceMetadataEnabled ? resolveBuildLocalMarkerSalt(process.env) : void 0;
+	const injected = {
+		[BUILD_ID_LITERAL]: identity.buildId,
+		[GIT_COMMIT_LITERAL]: identity.gitCommit ?? "",
+		[BUILD_MODE_LITERAL]: sourceMapUpload?.mode ?? configuredReleaseMode(options.sourceMaps) ?? inferReleaseMode(process.env)
+	};
+	if (typeof nextConfig === "function") return function visualReviewNextConfig(...arguments_) {
+		const resolved = nextConfig.apply(this, arguments_);
+		return isPromiseLike(resolved) ? resolved.then((config) => configureNext(config, injected, identity, sourceMapUpload, sourceMetadataEnabled, sourceMarkerSalt)) : configureNext(resolved, injected, identity, sourceMapUpload, sourceMetadataEnabled, sourceMarkerSalt);
+	};
+	return configureNext(nextConfig, injected, identity, sourceMapUpload, sourceMetadataEnabled, sourceMarkerSalt);
+}
+function configureNext(nextConfig, injected, identity, sourceMapUpload, sourceMetadataEnabled, sourceMarkerSalt) {
+	const previousHookMetadata = getVisualReviewHookMetadata(nextConfig.compiler?.runAfterProductionCompile);
+	const previouslyWrapped = isVisualReviewConfig(nextConfig) || previousHookMetadata !== void 0;
+	assertReservedLiterals(nextConfig.env, injected, previouslyWrapped);
+	let configured = {
+		...nextConfig,
+		env: {
+			...nextConfig.env,
+			...injected
+		}
+	};
+	if (previousHookMetadata) configured = restoreSourceMapConfiguration(configured, previousHookMetadata);
+	if (!sourceMapUpload && !sourceMetadataEnabled) return markVisualReviewConfig(configured);
+	const hookMetadata = previousHookMetadata ?? captureHookMetadata(nextConfig);
+	if (sourceMapUpload && (nextConfig.productionBrowserSourceMaps === false || hookMetadata.productionBrowserSourceMaps.present && hookMetadata.productionBrowserSourceMaps.value === false)) throw new Error("Next productionBrowserSourceMaps=false conflicts with Visual Review source-map upload");
+	if (sourceMapUpload && (nextConfig.experimental?.serverSourceMaps === false || hookMetadata.serverSourceMaps.present && hookMetadata.serverSourceMaps.value === false)) throw new Error("Next experimental.serverSourceMaps=false conflicts with Visual Review source-map upload");
+	const sourceMetadata = sourceMetadataEnabled ? resolveNextSourceMetadata(identity, nextConfig.basePath, sourceMarkerSalt) : void 0;
+	const sourceConfigured = sourceMetadata ? configureNextSourceMetadata(configured, hookMetadata, sourceMetadata) : configured;
+	const compiler = sourceConfigured.compiler ?? {};
+	return markVisualReviewConfig({
+		...sourceConfigured,
+		...sourceMapUpload ? { productionBrowserSourceMaps: true } : {},
+		...sourceMapUpload ? { experimental: {
+			...sourceConfigured.experimental,
+			serverSourceMaps: true
+		} } : {},
+		compiler: {
+			...compiler,
+			runAfterProductionCompile: composeProductionCompileHook(hookMetadata.originalHook, identity, sourceMapUpload, sourceMetadata, nextConfig.basePath, nextConfig.assetPrefix, hookMetadata)
+		}
+	});
+}
+function composeProductionCompileHook(existingHook, identity, sourceMapUpload, sourceMetadata, basePath, assetPrefix, metadata) {
+	const hook = async function visualReviewAfterProductionCompile(metadata) {
+		if (sourceMetadata) removeBuildLocalMarkerSalt(sourceMetadata.saltPath);
+		if (existingHook) try {
+			await existingHook.call(this, metadata);
+		} catch (existingError) {
+			if (!sourceMapUpload) throw existingError;
+			try {
+				await cleanupNextSourceMapOutput(metadata.projectDir, metadata.distDir);
+			} catch (cleanupError) {
+				throw new AggregateError([existingError, cleanupError], "Next.js production compile hook failed and Visual Review could not clean source maps");
+			}
+			throw existingError;
+		}
+		if (sourceMetadata) try {
+			await writeNextVisualReviewSourceIndex({
+				projectDir: metadata.projectDir,
+				distDir: metadata.distDir,
+				filename: sourceMetadata.filename,
+				...basePath ? { basePath } : {},
+				...assetPrefix ? { assetPrefix } : {}
+			});
+		} catch (sourceIndexError) {
+			if (!sourceMapUpload) throw sourceIndexError;
+			try {
+				await cleanupNextSourceMapOutput(metadata.projectDir, metadata.distDir);
+			} catch (cleanupError) {
+				throw new AggregateError([sourceIndexError, cleanupError], "Visual Review source index failed and Next.js source maps could not be cleaned");
+			}
+			throw sourceIndexError;
+		}
+		if (!sourceMapUpload) return;
+		await uploadNextSourceMaps({
+			projectRoot: metadata.projectDir,
+			distDir: metadata.distDir,
+			token: sourceMapUpload.token,
+			...sourceMapUpload.serviceUrl ? { serviceUrl: sourceMapUpload.serviceUrl } : {},
+			buildId: identity.buildId,
+			gitCommit: identity.gitCommit,
+			mode: sourceMapUpload.mode,
+			...basePath ? { basePath } : {},
+			...assetPrefix ? { assetPrefix } : {}
+		});
+	};
+	Object.defineProperty(hook, VISUAL_REVIEW_HOOK, { value: metadata });
+	return hook;
+}
+function getVisualReviewHookMetadata(hook) {
+	return hook?.[VISUAL_REVIEW_HOOK];
+}
+function captureHookMetadata(nextConfig) {
+	return {
+		originalHook: nextConfig.compiler?.runAfterProductionCompile,
+		compilerPresent: Object.prototype.hasOwnProperty.call(nextConfig, "compiler"),
+		experimentalPresent: Object.prototype.hasOwnProperty.call(nextConfig, "experimental"),
+		productionBrowserSourceMaps: propertyState(nextConfig, "productionBrowserSourceMaps"),
+		serverSourceMaps: propertyState(nextConfig.experimental, "serverSourceMaps"),
+		turbopack: propertyState(nextConfig, "turbopack"),
+		webpack: propertyState(nextConfig, "webpack")
+	};
+}
+function propertyState(value, key) {
+	return {
+		present: value !== void 0 && Object.prototype.hasOwnProperty.call(value, key),
+		value: value?.[key]
+	};
+}
+function restoreSourceMapConfiguration(configured, metadata) {
+	if (!metadata) return configured;
+	const restored = { ...configured };
+	if (metadata.productionBrowserSourceMaps.present) restored.productionBrowserSourceMaps = metadata.productionBrowserSourceMaps.value;
+	else delete restored.productionBrowserSourceMaps;
+	const experimental = { ...restored.experimental ?? {} };
+	if (metadata.serverSourceMaps.present) experimental.serverSourceMaps = metadata.serverSourceMaps.value;
+	else delete experimental.serverSourceMaps;
+	if (!metadata.experimentalPresent && Object.keys(experimental).length === 0) delete restored.experimental;
+	else restored.experimental = experimental;
+	const compiler = { ...restored.compiler ?? {} };
+	if (metadata.originalHook) compiler.runAfterProductionCompile = metadata.originalHook;
+	else delete compiler.runAfterProductionCompile;
+	if (!metadata.compilerPresent && Object.keys(compiler).length === 0) delete restored.compiler;
+	else restored.compiler = compiler;
+	restoreProperty(restored, "turbopack", metadata.turbopack);
+	restoreProperty(restored, "webpack", metadata.webpack);
+	return restored;
+}
+function restoreProperty(target, key, state) {
+	if (state.present) target[key] = state.value;
+	else delete target[key];
+}
+function resolveNextSourceMetadata(identity, basePath, markerSalt) {
+	if (!markerSalt) throw new Error("Visual Review source marker salt is unavailable");
+	const filename = visualReviewSourceIndexFilename(identity.buildId, markerSalt.salt);
+	const loaderUrl = new URL("./source-loader.js", import.meta.url);
+	return {
+		filename,
+		indexUrl: nextSourceIndexUrl(basePath, filename),
+		loader: loaderUrl.protocol === "file:" ? fileURLToPath(loaderUrl) : resolve(process.cwd(), "packages/review-client/dist/source-loader.js"),
+		saltPath: markerSalt.path
+	};
+}
+/**
+* Generates the marker salt and persists it outside the project so compiler
+* workers can read it without the secret entering any build output. The file is
+* owner-only and is removed once the production compile hook has run.
+*/
+function resolveBuildLocalMarkerSalt(env) {
+	const inherited = env[NEXT_MARKER_SALT_PATH];
+	if (env.NEXT_PRIVATE_BUILD_WORKER === "1" && env.IS_NEXT_WORKER === "true" && typeof inherited === "string" && inherited.length > 0) return {
+		salt: readMarkerSaltFile(inherited),
+		path: inherited
+	};
+	const salt = randomBytes(32).toString("hex");
+	const path = join(mkdtempSync(join(tmpdir(), "visual-review-marker-salt-")), "salt");
+	writeFileSync(path, salt, {
+		encoding: "utf8",
+		mode: 384
+	});
+	env[NEXT_MARKER_SALT_PATH] = path;
+	trackBuildLocalMarkerSalt(path);
+	return {
+		salt,
+		path
+	};
+}
+function readMarkerSaltFile(saltPath) {
+	const salt = readFileSync(saltPath, "utf8").trim();
+	if (!/^[0-9a-f]{64}$/u.test(salt)) throw new Error("Visual Review inherited marker salt is invalid");
+	return salt;
+}
+/**
+* `next dev` never reaches the production compile hook, and every compiler
+* worker evaluates the config in its own process, so exit is the only point
+* that reliably removes each salt file it created.
+*/
+function trackBuildLocalMarkerSalt(saltPath) {
+	if (trackedMarkerSaltPaths.size === 0) process.once("exit", () => {
+		for (const tracked of trackedMarkerSaltPaths) removeMarkerSaltDirectory(tracked);
+	});
+	trackedMarkerSaltPaths.add(saltPath);
+}
+function removeBuildLocalMarkerSalt(saltPath) {
+	trackedMarkerSaltPaths.delete(saltPath);
+	removeMarkerSaltDirectory(saltPath);
+}
+function removeMarkerSaltDirectory(saltPath) {
+	try {
+		rmSync(dirname(saltPath), {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+}
+function configureNextSourceMetadata(configured, metadata, sourceMetadata) {
+	const bundler = resolveNextBundler();
+	const next = { ...configured };
+	restoreProperty(next, "turbopack", metadata.turbopack);
+	restoreProperty(next, "webpack", metadata.webpack);
+	if (bundler === "turbopack") next.turbopack = appendTurbopackRules(next.turbopack, sourceMetadata);
+	else next.webpack = appendWebpackRule(next.webpack, sourceMetadata);
+	return next;
+}
+function resolveNextBundler() {
+	return process.env.TURBOPACK ? "turbopack" : "webpack";
+}
+function appendWebpackRule(existing, sourceMetadata) {
+	return (config, context) => {
+		const resolved = existing?.(config, context) ?? config;
+		if (!resolved || typeof resolved !== "object" || isPromiseLikeUnknown(resolved)) throw new Error("Next webpack() must return a synchronous config for Visual Review");
+		const webpackConfig = resolved;
+		const moduleConfig = isRecord(webpackConfig.module) ? webpackConfig.module : {};
+		const rules = Array.isArray(moduleConfig.rules) ? moduleConfig.rules : [];
+		return {
+			...webpackConfig,
+			module: {
+				...moduleConfig,
+				rules: [...rules, {
+					enforce: "pre",
+					exclude: /node_modules/u,
+					test: /\.[cm]?[jt]sx?$/u,
+					use: [{
+						loader: sourceMetadata.loader,
+						options: {
+							indexUrl: sourceMetadata.indexUrl,
+							saltPath: sourceMetadata.saltPath
+						}
+					}]
+				}]
+			}
+		};
+	};
+}
+function appendTurbopackRules(existing, sourceMetadata) {
+	const rules = { ...existing?.rules ?? {} };
+	for (const extension of [
+		"js",
+		"jsx",
+		"ts",
+		"tsx"
+	]) {
+		const pattern = `*.${extension}`;
+		const rule = {
+			condition: { all: [{ not: "foreign" }, "production"] },
+			loaders: [{
+				loader: sourceMetadata.loader,
+				options: {
+					compile: true,
+					indexUrl: sourceMetadata.indexUrl,
+					saltPath: sourceMetadata.saltPath
+				}
+			}]
+		};
+		const current = rules[pattern];
+		rules[pattern] = current === void 0 ? rule : Array.isArray(current) ? [...current, rule] : [current, rule];
+	}
+	return {
+		...existing,
+		rules
+	};
+}
+function isPromiseLikeUnknown(value) {
+	return Boolean(value) && typeof value === "object" && typeof value.then === "function";
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isVisualReviewConfig(config) {
+	return Boolean(config[VISUAL_REVIEW_CONFIG]);
+}
+function markVisualReviewConfig(config) {
+	Object.defineProperty(config, VISUAL_REVIEW_CONFIG, { value: true });
+	return config;
+}
+function resolveSourceMapUpload(option, env) {
+	if (option === false || typeof option === "object" && option.enabled === false) return;
+	const configured = typeof option === "object" ? option : void 0;
+	const token = configured?.token ?? env.VISUAL_REVIEW_SOURCE_MAP_TOKEN;
+	if (!(option === true || configured !== void 0 || token !== void 0)) return void 0;
+	if (typeof token !== "string" || token.length === 0 || token.length > 4096 || /\s/u.test(token)) throw new Error("Visual Review source-map upload requires VISUAL_REVIEW_SOURCE_MAP_TOKEN in the Node build environment");
+	return {
+		token,
+		mode: configured?.mode ?? inferReleaseMode(env),
+		...configured?.serviceUrl ? { serviceUrl: configured.serviceUrl } : {}
+	};
+}
+function configuredReleaseMode(option) {
+	return typeof option === "object" ? option.mode : void 0;
+}
+function inferReleaseMode(env) {
+	if (env.VERCEL_ENV === "preview") return "preview";
+	if (env.VERCEL_ENV === "development") return "development";
+	if (env.CONTEXT === "deploy-preview" || env.CONTEXT === "branch-deploy") return "preview";
+	if (env.NODE_ENV === "development") return "development";
+	return "production";
+}
+function isPromiseLike(value) {
+	return typeof value.then === "function";
+}
+function assertReservedLiterals(current, expected, allowVisualReviewOverride = false) {
+	if (!current) return;
+	for (const key of [
+		BUILD_ID_LITERAL,
+		GIT_COMMIT_LITERAL,
+		BUILD_MODE_LITERAL
+	]) if (!allowVisualReviewOverride && Object.prototype.hasOwnProperty.call(current, key) && current[key] !== expected[key]) throw new Error(`Next env already defines reserved ${key}; configure it through withVisualReview() options`);
+}
+//#endregion
+export { withVisualReview };

package/dist/next.d.ts

@@ -0,0 +1 @@
+export { VisualReview, type VisualReviewProps } from './react.js';

package/dist/next.js

@@ -0,0 +1 @@
+"use client";import{VisualReview as e}from"./react.js";export{e as VisualReview};