@module-federation/observability-plugin 0.0.0-alpha.0

package/dist/esm/build.js

@@ -0,0 +1,679 @@
+import fs from "node:fs";
+import path from "node:path";
+import { simpleJoinRemoteEntry } from "@module-federation/sdk";
+
+//#region src/build.ts
+const PLUGIN_NAME = "ObservabilityBuildPlugin";
+const DEFAULT_OUTPUT_FILE = ".mf/observability/build-info.json";
+const DEFAULT_REPORT_FILE = ".mf/observability/build-report.json";
+const DEFAULT_MANIFEST_FILE = "mf-manifest.json";
+const DEFAULT_STATS_FILE = "mf-stats.json";
+const ERROR_CODE_PATTERN = /\b(?:RUNTIME|TYPE|BUILD)-\d{3}\b/;
+const MAX_BUILD_FACT_KEYS = 50;
+const SENSITIVE_PAIR_PATTERN = /\b(token|authorization|cookie|secret|password|session|access_token|refresh_token|api_key|apikey|key)\s*[:=]\s*([^&\s'",;<>]+)/gi;
+const URL_PATTERN = /https?:\/\/[^\s'"<>]+/g;
+const ABSOLUTE_PATH_PATTERN = /(?:file:\/\/)?(?:\/(?:Users|private|var|tmp|home|workspace|opt|usr)\/[^\s)]+|[A-Za-z]:\\[^\s)]+)/g;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function getRecord(value) {
+	return isRecord(value) ? value : void 0;
+}
+function getString(value) {
+	return typeof value === "string" && value ? value : void 0;
+}
+function getBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function sanitizeText(value, maxLength = 240) {
+	if (value === void 0 || value === null) return;
+	const sanitized = String(value).replace(URL_PATTERN, (url) => sanitizeUrl(url) || "[redacted-url]").replace(ABSOLUTE_PATH_PATTERN, "[redacted-path]").replace(SENSITIVE_PAIR_PATTERN, "[redacted]");
+	return sanitized.length > maxLength ? `${sanitized.slice(0, maxLength)}...` : sanitized;
+}
+function getRawText(value) {
+	if (value === void 0 || value === null) return;
+	return String(value);
+}
+function clipText(value, maxLength = 320) {
+	if (value === void 0 || value === null) return;
+	const sanitized = String(value);
+	return sanitized.length > maxLength ? `${sanitized.slice(0, maxLength)}...` : sanitized;
+}
+function sanitizeStack(value) {
+	const stack = getString(value);
+	if (!stack) return;
+	return stack;
+}
+function extractErrorCode(value) {
+	return sanitizeText(String(value ?? "").match(ERROR_CODE_PATTERN)?.[0], 40);
+}
+function sanitizeUrl(value) {
+	if (!value) return;
+	try {
+		const parsedUrl = new URL(value, "http://localhost");
+		const sanitized = `${parsedUrl.origin}${parsedUrl.pathname}`;
+		return /^https?:\/\//i.test(value) ? sanitized : parsedUrl.pathname;
+	} catch {
+		const [withoutHash] = value.split("#");
+		const [withoutQuery] = withoutHash.split("?");
+		return sanitizeText(withoutQuery, 320);
+	}
+}
+function sanitizeRemoteEntry(value) {
+	const raw = getString(value);
+	if (!raw) return;
+	const atIndex = raw.lastIndexOf("@");
+	if (atIndex > 0) {
+		const remoteName = sanitizeText(raw.slice(0, atIndex), 120);
+		const entry = clipText(raw.slice(atIndex + 1), 320);
+		if (remoteName && entry) return `${remoteName}@${entry}`;
+		return entry || remoteName;
+	}
+	return clipText(raw, 320);
+}
+function sanitizePublicPath(value) {
+	const raw = getString(value);
+	if (!raw) return;
+	return clipText(raw, 320);
+}
+function getSanitizedString(value, maxLength = 160) {
+	return sanitizeText(value, maxLength);
+}
+function normalizeStringArray(value) {
+	if (!Array.isArray(value)) {
+		const sanitized = getSanitizedString(value);
+		return sanitized ? [sanitized] : void 0;
+	}
+	const values = value.map((item) => getSanitizedString(item)).filter((item) => Boolean(item));
+	return values.length ? values.slice(0, 20) : void 0;
+}
+function normalizeShareScope(value) {
+	if (Array.isArray(value)) {
+		const scopes = normalizeStringArray(value);
+		return scopes?.length ? scopes : void 0;
+	}
+	return getSanitizedString(value);
+}
+function normalizeRequiredVersion(value) {
+	if (value === false) return false;
+	return getSanitizedString(value, 120);
+}
+function normalizeManifestOption(value) {
+	if (typeof value === "boolean") return value;
+	const manifestOptions = getRecord(value);
+	if (!manifestOptions) return;
+	return getSanitizedString(manifestOptions["fileName"], 120) || true;
+}
+function getManifestFileName(manifestOption) {
+	const manifestOptions = getRecord(manifestOption);
+	const filePath = getString(manifestOptions?.["filePath"]) || "";
+	const fileName = getString(manifestOptions?.["fileName"]);
+	const manifestFile = fileName ? addJsonExtension(fileName) : DEFAULT_MANIFEST_FILE;
+	const statsFile = fileName ? insertSuffix(addJsonExtension(fileName), "-stats") : DEFAULT_STATS_FILE;
+	return {
+		manifestFileName: simpleJoinRemoteEntry(filePath, manifestFile),
+		statsFileName: simpleJoinRemoteEntry(filePath, statsFile)
+	};
+}
+function addJsonExtension(fileName) {
+	return /\.json$/i.test(fileName) ? fileName : `${fileName}.json`;
+}
+function insertSuffix(fileName, suffix) {
+	return fileName.replace(/\.json$/i, `${suffix}.json`);
+}
+function getSourceText(source) {
+	if (source === void 0 || source === null) return;
+	if (typeof source === "string") return source;
+	if (typeof source === "function") try {
+		return getSourceText(source());
+	} catch {
+		return;
+	}
+	const sourceFn = getRecord(source)?.["source"];
+	if (typeof sourceFn === "function") try {
+		return getSourceText(sourceFn.call(source));
+	} catch {
+		return;
+	}
+	return String(source);
+}
+function readAssetText(compilation, fileName) {
+	const asset = compilation.getAsset?.(fileName);
+	const assetSource = asset ? getSourceText(asset.source) : void 0;
+	if (assetSource !== void 0) return assetSource;
+	const legacyAsset = compilation.assets?.[fileName];
+	return getSourceText(legacyAsset);
+}
+function readJsonAsset(compilation, fileName) {
+	const text = readAssetText(compilation, fileName);
+	if (!text) return;
+	try {
+		return getRecord(JSON.parse(text));
+	} catch {
+		return;
+	}
+}
+function getRemoteParts(value) {
+	const raw = getString(value);
+	if (!raw) return {};
+	const atIndex = raw.lastIndexOf("@");
+	if (atIndex > 0) return {
+		name: getSanitizedString(raw.slice(0, atIndex), 120),
+		entry: sanitizeRemoteEntry(raw.slice(atIndex + 1))
+	};
+	return { entry: sanitizeRemoteEntry(raw) };
+}
+function normalizeRemoteFromConfig(alias, value) {
+	const remote = { alias: getSanitizedString(alias, 120) };
+	if (typeof value === "string") {
+		const parts = getRemoteParts(value);
+		remote.name = parts.name || remote.alias;
+		remote.entry = parts.entry;
+		return remote.name || remote.entry ? remote : void 0;
+	}
+	if (Array.isArray(value)) return normalizeRemoteFromConfig(alias, value.find((item) => typeof item === "string" || isRecord(item)));
+	const remoteOptions = getRecord(value);
+	if (!remoteOptions) return remote.alias ? remote : void 0;
+	const entryValue = remoteOptions["entry"] || remoteOptions["external"] || remoteOptions["version"];
+	const parts = getRemoteParts(entryValue);
+	remote.name = getSanitizedString(remoteOptions["name"], 120) || getSanitizedString(remoteOptions["federationContainerName"], 120) || parts.name || remote.alias;
+	remote.alias = getSanitizedString(remoteOptions["alias"], 120) || remote.alias;
+	remote.entry = parts.entry || sanitizeRemoteEntry(entryValue);
+	remote.type = getSanitizedString(remoteOptions["type"], 80);
+	remote.shareScope = normalizeShareScope(remoteOptions["shareScope"]);
+	return remote.name || remote.entry ? remote : void 0;
+}
+function normalizeRemoteFromManifest(value) {
+	const remoteOptions = getRecord(value);
+	if (!remoteOptions) return;
+	const entryValue = remoteOptions["entry"] || remoteOptions["version"];
+	const remote = {
+		name: getSanitizedString(remoteOptions["moduleName"], 120) || getSanitizedString(remoteOptions["name"], 120) || getSanitizedString(remoteOptions["federationContainerName"], 120),
+		alias: getSanitizedString(remoteOptions["alias"], 120),
+		entry: sanitizeRemoteEntry(entryValue),
+		type: getSanitizedString(remoteOptions["type"], 80),
+		shareScope: normalizeShareScope(remoteOptions["shareScope"])
+	};
+	return remote.name || remote.entry ? remote : void 0;
+}
+function normalizeConfigRemotes(value) {
+	if (Array.isArray(value)) return value.map((item) => normalizeRemoteFromConfig(void 0, item)).filter((item) => Boolean(item));
+	const remotes = getRecord(value);
+	if (!remotes) return [];
+	return Object.entries(remotes).map(([alias, remote]) => normalizeRemoteFromConfig(alias, remote)).filter((remote) => Boolean(remote));
+}
+function normalizeManifestRemotes(value) {
+	return (Array.isArray(value) ? value : []).map(normalizeRemoteFromManifest).filter((remote) => Boolean(remote));
+}
+function normalizeConfigExposes(value) {
+	if (Array.isArray(value)) return value.map((item) => typeof item === "string" ? getSanitizedString(item, 160) : getSanitizedString(getRecord(item)?.["name"], 160)).filter((name) => Boolean(name)).map((name) => ({ name }));
+	const exposes = getRecord(value);
+	if (!exposes) return [];
+	return Object.keys(exposes).map((name) => getSanitizedString(name, 160)).filter((name) => Boolean(name)).map((name) => ({ name }));
+}
+function normalizeManifestExposes(value) {
+	return (Array.isArray(value) ? value : []).map((item) => {
+		const expose = getRecord(item);
+		return getSanitizedString(expose?.["name"], 160) || getSanitizedString(expose?.["id"], 160);
+	}).filter((name) => Boolean(name)).map((name) => ({ name }));
+}
+function normalizeSharedFromRecord(name, value) {
+	const sharedOptions = getRecord(value);
+	if (!sharedOptions) {
+		const sharedName = name || (typeof value === "string" ? getSanitizedString(value, 160) : void 0);
+		return sharedName ? { name: sharedName } : void 0;
+	}
+	const sharedName = getSanitizedString(sharedOptions["name"], 160) || getSanitizedString(sharedOptions["shareKey"], 160) || name;
+	if (!sharedName) return;
+	return {
+		name: sharedName,
+		shareScope: normalizeShareScope(sharedOptions["shareScope"]),
+		version: getSanitizedString(sharedOptions["version"], 120),
+		requiredVersion: normalizeRequiredVersion(sharedOptions["requiredVersion"]),
+		singleton: getBoolean(sharedOptions["singleton"]),
+		strictVersion: getBoolean(sharedOptions["strictVersion"]),
+		eager: getBoolean(sharedOptions["eager"])
+	};
+}
+function normalizeConfigShared(value) {
+	if (Array.isArray(value)) return value.map((item) => normalizeSharedFromRecord(void 0, item)).filter((shared) => Boolean(shared));
+	const shared = getRecord(value);
+	if (!shared) return [];
+	return Object.entries(shared).map(([name, sharedOptions]) => normalizeSharedFromRecord(getSanitizedString(name, 160), sharedOptions)).filter((item) => Boolean(item));
+}
+function normalizeManifestShared(value) {
+	return (Array.isArray(value) ? value : []).map((item) => {
+		const sharedOptions = getRecord(item);
+		return normalizeSharedFromRecord(getSanitizedString(sharedOptions?.["name"], 160) || getSanitizedString(sharedOptions?.["id"], 160), sharedOptions);
+	}).filter((shared) => Boolean(shared));
+}
+function getPublicPathInfo(metaData, compilerOptions) {
+	const outputOptions = getRecord(compilerOptions?.["output"]);
+	const getPublicPath = metaData?.["getPublicPath"];
+	const publicPath = metaData?.["publicPath"] || outputOptions?.["publicPath"];
+	if (getPublicPath) return {
+		mode: "runtime-getter",
+		value: void 0
+	};
+	const sanitizedPublicPath = sanitizePublicPath(publicPath);
+	if (publicPath === "auto") return {
+		mode: "auto",
+		value: "auto"
+	};
+	if (sanitizedPublicPath) return {
+		mode: "static",
+		value: sanitizedPublicPath
+	};
+	return {
+		mode: "unknown",
+		value: void 0
+	};
+}
+function normalizeTarget(value) {
+	return normalizeStringArray(value);
+}
+function getManifestSource(manifest, stats) {
+	return manifest || stats;
+}
+function getMetaData(manifest, stats) {
+	return getRecord(manifest?.["metaData"]) || getRecord(stats?.["metaData"]) || void 0;
+}
+function getBuildInfo(metaData) {
+	return getRecord(metaData?.["buildInfo"]);
+}
+function getSource(manifest, stats) {
+	if (manifest) return "manifest";
+	if (stats) return "stats";
+	return "config";
+}
+function getConfigOptions(moduleFederation) {
+	return getRecord(moduleFederation) || {};
+}
+function getRemoteEntryType(moduleFederation, metaData) {
+	const remoteEntry = getRecord(metaData?.["remoteEntry"]);
+	const library = getRecord(moduleFederation["library"]);
+	return getSanitizedString(remoteEntry?.["type"], 80) || getSanitizedString(library?.["type"], 80);
+}
+function getRemoteEntryName(moduleFederation, metaData) {
+	return getSanitizedString(getRecord(metaData?.["remoteEntry"])?.["name"], 160) || getSanitizedString(moduleFederation["filename"], 160);
+}
+function getGlobalName(moduleFederation, metaData) {
+	const library = getRecord(moduleFederation["library"]);
+	return getSanitizedString(metaData?.["globalName"], 160) || getSanitizedString(library?.["name"], 160);
+}
+function getBundlerName(inputBundler, compilerOptions) {
+	return getSanitizedString(inputBundler, 80) || getSanitizedString(compilerOptions?.["name"], 80) || "unknown";
+}
+function getBundlerVersion(inputVersion, compilerOptions) {
+	return getSanitizedString(inputVersion, 80) || getSanitizedString(compilerOptions?.["webpackVersion"], 80);
+}
+function getDtsOption(value) {
+	if (value === false) return false;
+	if (value === void 0) return;
+	return true;
+}
+function getAsyncStartup(moduleFederation) {
+	return getBoolean(getRecord(moduleFederation["experiments"])?.["asyncStartup"]);
+}
+function uniqueByName(items) {
+	const seen = /* @__PURE__ */ new Set();
+	return items.filter((item) => {
+		const key = item.name || JSON.stringify(item);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function createObservabilityBuildInfo(input) {
+	const moduleFederation = getConfigOptions(input.moduleFederation);
+	const manifest = getRecord(input.manifest);
+	const stats = getRecord(input.stats);
+	const manifestSource = getManifestSource(manifest, stats);
+	const metaData = getMetaData(manifest, stats);
+	const buildInfo = getBuildInfo(metaData);
+	const publicPath = getPublicPathInfo(metaData, input.compilerOptions);
+	const manifestRemotes = normalizeManifestRemotes(manifestSource?.["remotes"]);
+	const manifestExposes = normalizeManifestExposes(manifestSource?.["exposes"]);
+	const manifestShared = normalizeManifestShared(manifestSource?.["shared"]);
+	const remotes = uniqueByName(manifestRemotes.length ? manifestRemotes : normalizeConfigRemotes(moduleFederation["remotes"]));
+	const exposes = uniqueByName(manifestExposes.length ? manifestExposes : normalizeConfigExposes(moduleFederation["exposes"]));
+	const shared = uniqueByName(manifestShared.length ? manifestShared : normalizeConfigShared(moduleFederation["shared"]));
+	return {
+		schemaVersion: 1,
+		generatedAt: input.generatedAt || (/* @__PURE__ */ new Date()).toISOString(),
+		source: getSource(manifest, stats),
+		bundler: {
+			name: getBundlerName(input.bundler, input.compilerOptions),
+			version: getBundlerVersion(input.bundlerVersion, input.compilerOptions),
+			mode: getSanitizedString(input.compilerOptions?.["mode"], 80),
+			target: normalizeTarget(input.compilerOptions?.["target"])
+		},
+		moduleFederation: {
+			name: getSanitizedString(manifestSource?.["name"], 160) || getSanitizedString(metaData?.["name"], 160) || getSanitizedString(moduleFederation["name"], 160),
+			pluginVersion: getSanitizedString(metaData?.["pluginVersion"], 80) || getSanitizedString(input.pluginVersion, 80),
+			buildVersion: getSanitizedString(buildInfo?.["buildVersion"], 160),
+			buildName: getSanitizedString(buildInfo?.["buildName"], 160),
+			remoteEntry: {
+				name: getRemoteEntryName(moduleFederation, metaData),
+				type: getRemoteEntryType(moduleFederation, metaData),
+				globalName: getGlobalName(moduleFederation, metaData),
+				publicPath: publicPath.value,
+				publicPathMode: publicPath.mode
+			},
+			options: {
+				shareStrategy: getSanitizedString(moduleFederation["shareStrategy"], 80),
+				shareScope: normalizeShareScope(moduleFederation["shareScope"]),
+				asyncStartup: getAsyncStartup(moduleFederation),
+				manifest: normalizeManifestOption(moduleFederation["manifest"]),
+				dts: getDtsOption(moduleFederation["dts"])
+			},
+			remotes,
+			exposes,
+			shared
+		},
+		summary: {
+			remoteCount: remotes.length,
+			exposeCount: exposes.length,
+			sharedCount: shared.length
+		}
+	};
+}
+function getErrorRecord(error) {
+	return getRecord(error);
+}
+function getErrorName(error) {
+	if (error instanceof Error) return getSanitizedString(error.name, 120);
+	const errorRecord = getErrorRecord(error);
+	const constructorName = typeof error === "object" && error !== null ? getSanitizedString(error.constructor?.name, 120) : void 0;
+	return getSanitizedString(errorRecord?.["name"], 120) || constructorName;
+}
+function getErrorMessage(error) {
+	if (error instanceof Error) return getRawText(error.message);
+	return getRawText(getErrorRecord(error)?.["message"]) || getRawText(error);
+}
+function getErrorStack(error) {
+	if (error instanceof Error) return sanitizeStack(error.stack);
+	return sanitizeStack(getErrorRecord(error)?.["stack"]);
+}
+function getBuildOwnerHint(error, phase) {
+	if (phase === "observability-output") return "build";
+	const text = `${getErrorName(error) || ""}\n${getErrorMessage(error) || ""}\n${getErrorStack(error) || ""}`;
+	if (/shared|shareScope|singleton|strictVersion|eager/i.test(text)) return "shared";
+	if (/remote|manifest|remoteEntry|expose|container/i.test(text)) return "remote";
+	if (/host|ModuleFederationPlugin|federation/i.test(text)) return "host";
+	return "build";
+}
+function createBuildErrorEvent(traceId, error, phase) {
+	const timestamp = Date.now();
+	const errorName = getErrorName(error);
+	const errorMessage = getErrorMessage(error);
+	const errorStack = getErrorStack(error);
+	return {
+		traceId,
+		timestamp,
+		phase: "build",
+		status: "error",
+		lifecycle: phase,
+		failedPhase: phase,
+		errorCode: extractErrorCode(`${errorName || ""}\n${errorMessage || ""}\n${errorStack || ""}`),
+		errorName,
+		errorMessage,
+		errorStack,
+		ownerHint: getBuildOwnerHint(error, phase),
+		retryable: false,
+		context: { lifecycle: phase }
+	};
+}
+function copyBuildErrorSummary(event) {
+	return {
+		errorCode: event.errorCode,
+		errorName: event.errorName,
+		errorMessage: event.errorMessage,
+		failedPhase: event.failedPhase,
+		ownerHint: event.ownerHint,
+		retryable: event.retryable,
+		context: event.context ? { ...event.context } : void 0
+	};
+}
+function createBuildFacts(buildInfo, phase, primaryError) {
+	const facts = {};
+	const addFact = (key, value) => {
+		if (value === void 0 || value === null || value === "") return;
+		facts[key] = Array.isArray(value) ? value.join(",") : value;
+	};
+	addFact("source", "build");
+	addFact("status", "error");
+	addFact("outcome", "failed");
+	addFact("failedPhase", phase);
+	addFact("errorCode", primaryError?.errorCode);
+	addFact("errorName", primaryError?.errorName);
+	addFact("ownerHint", primaryError?.ownerHint);
+	addFact("retryable", primaryError?.retryable);
+	addFact("bundlerName", buildInfo.bundler.name);
+	addFact("bundlerVersion", buildInfo.bundler.version);
+	addFact("buildMode", buildInfo.bundler.mode);
+	addFact("buildTarget", buildInfo.bundler.target);
+	addFact("mfName", buildInfo.moduleFederation.name);
+	addFact("pluginVersion", buildInfo.moduleFederation.pluginVersion);
+	addFact("buildVersion", buildInfo.moduleFederation.buildVersion);
+	addFact("buildName", buildInfo.moduleFederation.buildName);
+	addFact("remoteEntryName", buildInfo.moduleFederation.remoteEntry?.name);
+	addFact("remoteEntryType", buildInfo.moduleFederation.remoteEntry?.type);
+	addFact("remoteEntryGlobalName", buildInfo.moduleFederation.remoteEntry?.globalName);
+	addFact("publicPathMode", buildInfo.moduleFederation.remoteEntry?.publicPathMode);
+	addFact("remoteCount", buildInfo.summary.remoteCount);
+	addFact("exposeCount", buildInfo.summary.exposeCount);
+	addFact("sharedCount", buildInfo.summary.sharedCount);
+	addFact("remotes", buildInfo.moduleFederation.remotes.map((remote) => remote.alias || remote.name || remote.entry).filter((value) => Boolean(value)));
+	addFact("exposes", buildInfo.moduleFederation.exposes.map((expose) => expose.name));
+	addFact("shared", buildInfo.moduleFederation.shared.map((shared) => shared.name));
+	addFact("eagerShared", buildInfo.moduleFederation.shared.filter((shared) => shared.eager).map((shared) => shared.name));
+	return Object.entries(facts).slice(0, MAX_BUILD_FACT_KEYS).reduce((memo, [key, value]) => {
+		const sanitizedKey = sanitizeText(key, 80);
+		if (!sanitizedKey) return memo;
+		if (typeof value === "boolean") {
+			memo[sanitizedKey] = value;
+			return memo;
+		}
+		if (typeof value === "number") {
+			if (Number.isFinite(value)) memo[sanitizedKey] = value;
+			return memo;
+		}
+		const sanitizedValue = clipText(value, 240);
+		if (sanitizedValue) memo[sanitizedKey] = sanitizedValue;
+		return memo;
+	}, {});
+}
+function createBuildActions(phase, ownerHint) {
+	const actions = [];
+	const pushAction = (id, title, hint = ownerHint) => {
+		actions.push({
+			id,
+			ownerHint: hint,
+			title
+		});
+	};
+	if (phase === "observability-output") {
+		pushAction("check-observability-output", "Check observability output path permissions and filesystem availability", "build");
+		return actions;
+	}
+	pushAction("inspect-build-errors", "Inspect the sanitized build error list for the first failing build phase", ownerHint);
+	if (ownerHint === "shared") pushAction("check-shared-config", "Check shared dependency configuration, versions, and eager settings", "shared");
+	else if (ownerHint === "remote") pushAction("check-remote-config", "Check remoteEntry, remotes, exposes, and manifest build output", "remote");
+	else pushAction("check-module-federation-config", "Check host Module Federation configuration and build options", ownerHint === "host" ? "host" : "build");
+	return actions;
+}
+function createBuildFactReport(buildInfo, phase, primaryError) {
+	const ownerHint = primaryError?.ownerHint || "build";
+	return {
+		title: phase === "observability-output" ? "Build observability output failed" : "Module Federation build failed",
+		outcome: "failed",
+		status: "error",
+		ownerHint,
+		failedPhase: phase,
+		errorCode: primaryError?.errorCode,
+		errorName: primaryError?.errorName,
+		errorMessage: primaryError?.errorMessage,
+		facts: createBuildFacts(buildInfo, phase, primaryError),
+		completedPhases: phase === "compilation" ? ["build-info"] : ["build-report"],
+		pendingPhases: [],
+		actions: createBuildActions(phase, ownerHint)
+	};
+}
+function createBuildReport(buildInfo, errors, phase, startedAt) {
+	const sanitizedErrors = errors.filter((error) => error !== void 0);
+	if (!sanitizedErrors.length) return;
+	const traceId = `mf-build-${Date.now().toString(36)}`;
+	const events = sanitizedErrors.slice(0, 20).map((error) => createBuildErrorEvent(traceId, error, phase));
+	const updatedAt = events[events.length - 1]?.timestamp || Date.now();
+	const errorsSummary = events.map(copyBuildErrorSummary);
+	const primaryError = errorsSummary[0];
+	return {
+		schemaVersion: 1,
+		traceId,
+		source: "build",
+		status: "error",
+		startedAt,
+		updatedAt,
+		duration: Math.max(0, updatedAt - startedAt),
+		failedPhase: phase,
+		build: buildInfo,
+		events,
+		summary: {
+			eventCount: events.length,
+			outcome: "failed",
+			error: primaryError,
+			errors: errorsSummary
+		},
+		diagnosis: createBuildFactReport(buildInfo, phase, primaryError)
+	};
+}
+function getModuleFederationOptions(options, compiler) {
+	if (options.moduleFederation) return options.moduleFederation;
+	const plugins = compiler.options?.["plugins"];
+	if (!Array.isArray(plugins)) return;
+	for (const plugin of plugins) {
+		const pluginRecord = getRecord(plugin);
+		if (!pluginRecord) continue;
+		if (getSanitizedString(pluginRecord["name"], 120) !== "ModuleFederationPlugin") continue;
+		return pluginRecord["_options"] || pluginRecord["options"];
+	}
+}
+function getCompilerOptions(compiler) {
+	return compiler.options || {};
+}
+function getBundlerFromCompiler(options, compiler) {
+	if (options.bundler) return options.bundler;
+	if (compiler.webpack?.rspackVersion) return "rspack";
+	return "webpack";
+}
+function getBundlerVersionFromCompiler(options, compiler) {
+	return options.bundlerVersion || compiler.webpack?.version;
+}
+function getProcessAssetsStage(compiler, compilation) {
+	return compilation.constructor?.PROCESS_ASSETS_STAGE_REPORT || compiler.webpack?.Compilation?.PROCESS_ASSETS_STAGE_REPORT || compilation.constructor?.PROCESS_ASSETS_STAGE_SUMMARIZE || compiler.webpack?.Compilation?.PROCESS_ASSETS_STAGE_SUMMARIZE;
+}
+function getOutputFile(options, compiler) {
+	return getResolvedOutputFile(options.outputFile || DEFAULT_OUTPUT_FILE, {
+		cwd: options.cwd,
+		compiler
+	});
+}
+function getResolvedOutputFile(outputFile, { cwd: configuredCwd, compiler }) {
+	const cwd = configuredCwd || getString(compiler.options?.["context"]) || compiler.context || process.cwd();
+	return path.isAbsolute(outputFile) ? outputFile : path.resolve(cwd, outputFile);
+}
+function getBuildReportOutputFile(options, compiler) {
+	const reportOptions = options.errorReport;
+	const outputFile = reportOptions === false ? void 0 : reportOptions?.outputFile || DEFAULT_REPORT_FILE;
+	return outputFile ? getResolvedOutputFile(outputFile, {
+		cwd: options.cwd,
+		compiler
+	}) : void 0;
+}
+function writeBuildInfo(buildInfo, options, compiler) {
+	const outputFile = getOutputFile(options, compiler);
+	fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+	fs.writeFileSync(outputFile, `${JSON.stringify(buildInfo, null, 2)}\n`, "utf8");
+}
+function writeBuildReport(report, options, compiler) {
+	const outputFile = getBuildReportOutputFile(options, compiler);
+	if (!outputFile) return;
+	fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+	fs.writeFileSync(outputFile, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+}
+function removeStaleBuildReport(options, compiler) {
+	const outputFile = getBuildReportOutputFile(options, compiler);
+	if (!outputFile || !fs.existsSync(outputFile)) return;
+	fs.rmSync(outputFile, { force: true });
+}
+function warn(compiler, error, action = "write build observability") {
+	const message = getRawText(error instanceof Error ? error.message : String(error)) || "unknown error";
+	(compiler.getInfrastructureLogger?.(PLUGIN_NAME))?.warn?.(`[${PLUGIN_NAME}] Failed to ${action}: ${message}`);
+}
+function writeBuildReportSafely(report, options, compiler) {
+	if (!report) return;
+	try {
+		writeBuildReport(report, options, compiler);
+	} catch (error) {
+		warn(compiler, error, "write build observability report");
+	}
+}
+var ObservabilityBuildPlugin = class {
+	constructor(options = {}) {
+		this.name = PLUGIN_NAME;
+		this.options = options;
+	}
+	apply(compiler) {
+		if (this.options.enabled === false) return;
+		compiler.hooks?.thisCompilation?.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks?.processAssets?.tapPromise({
+				name: PLUGIN_NAME,
+				stage: getProcessAssetsStage(compiler, compilation)
+			}, async () => {
+				const startedAt = Date.now();
+				try {
+					const moduleFederation = getModuleFederationOptions(this.options, compiler);
+					const fileNames = getManifestFileName(getRecord(moduleFederation)?.["manifest"]);
+					const buildInfo = createObservabilityBuildInfo({
+						moduleFederation,
+						manifest: readJsonAsset(compilation, fileNames.manifestFileName),
+						stats: readJsonAsset(compilation, fileNames.statsFileName),
+						compilerOptions: getCompilerOptions(compiler),
+						bundler: getBundlerFromCompiler(this.options, compiler),
+						bundlerVersion: getBundlerVersionFromCompiler(this.options, compiler),
+						pluginVersion: this.options.pluginVersion
+					});
+					let observabilityOutputFailed = false;
+					try {
+						writeBuildInfo(buildInfo, this.options, compiler);
+					} catch (error) {
+						observabilityOutputFailed = true;
+						warn(compiler, error);
+						writeBuildReportSafely(createBuildReport(buildInfo, [error], "observability-output", startedAt), this.options, compiler);
+					}
+					const compilationErrors = compilation.errors || [];
+					if (compilationErrors.length) writeBuildReportSafely(createBuildReport(buildInfo, compilationErrors, "compilation", startedAt), this.options, compiler);
+					else if (!observabilityOutputFailed) try {
+						removeStaleBuildReport(this.options, compiler);
+					} catch (error) {
+						warn(compiler, error, "remove stale build observability report");
+					}
+				} catch (error) {
+					const fallbackBuildInfo = createObservabilityBuildInfo({
+						moduleFederation: this.options.moduleFederation,
+						compilerOptions: getCompilerOptions(compiler),
+						bundler: getBundlerFromCompiler(this.options, compiler),
+						bundlerVersion: getBundlerVersionFromCompiler(this.options, compiler),
+						pluginVersion: this.options.pluginVersion
+					});
+					warn(compiler, error);
+					writeBuildReportSafely(createBuildReport(fallbackBuildInfo, [error], "observability-output", startedAt), this.options, compiler);
+				}
+			});
+		});
+	}
+};
+
+//#endregion
+export { ObservabilityBuildPlugin, createObservabilityBuildInfo };