@module-federation/observability-plugin 0.0.0-alpha.0 → 0.0.0-chore-bump-node-22-20260710161714

package/dist/index.js

@@ -1,1444 +1,9 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const require_core = require('./core--1ofIHU9.js');
+const require_browser = require('./browser.js');
+const require_chrome_devtool = require('./chrome-devtool.js');
 
-//#region src/index.ts
-const DEFAULT_MAX_EVENTS = 100;
-const HARD_MAX_EVENTS = 1e3;
-const COMPONENT_BUSINESS_LOADED_EVENT = "component:business-loaded";
-const SENSITIVE_PAIR_PATTERN = /\b(token|authorization|cookie|secret|password|session|access_token|refresh_token|api_key|apikey|key)\s*[:=]\s*([^&\s'",;<>]+)/gi;
-const ERROR_CODE_PATTERN = /\b(?:RUNTIME|TYPE|BUILD)-\d{3}\b/;
-const URL_PATTERN = /https?:\/\/[^\s'"<>]+/g;
-const DIAGNOSTIC_DOC_LINK_PATTERN = /https?:\/\/module-federation\.io\/guide\/troubleshooting\/[^\s'"<>]+/i;
-const RUNTIME_DOC_LINK = "https://module-federation.io/guide/troubleshooting/runtime";
-const MAX_METADATA_KEYS = 20;
-const MAX_FACT_KEYS = 50;
-const MAX_MODULE_INFO_ENTRIES = 20;
-const HARD_MAX_REPORT_QUERY_LIMIT = 1e3;
-let traceCounter = 0;
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function normalizeMaxEvents(value, fallback) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
-	return Math.max(1, Math.min(HARD_MAX_EVENTS, Math.floor(value)));
-}
-function normalizeQueryLimit(value) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return;
-	return Math.max(1, Math.min(HARD_MAX_REPORT_QUERY_LIMIT, Math.floor(value)));
-}
-function sanitizeText(value, maxLength = 800) {
-	if (value === void 0 || value === null) return;
-	const sanitized = String(value).replace(URL_PATTERN, (url) => sanitizeUrl(url) || "[redacted-url]").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 clipObservabilityMetadata(metadata, maxKeys = MAX_METADATA_KEYS) {
-	if (!metadata || typeof metadata !== "object") return;
-	const clipped = {};
-	Object.entries(metadata).slice(0, maxKeys).forEach(([rawKey, rawValue]) => {
-		const key = clipText(rawKey, 80);
-		if (!key || rawValue === void 0 || rawValue === null) return;
-		if (typeof rawValue === "boolean") {
-			clipped[key] = rawValue;
-			return;
-		}
-		if (typeof rawValue === "number") {
-			if (Number.isFinite(rawValue)) clipped[key] = rawValue;
-			return;
-		}
-		const value = clipText(rawValue, 240);
-		if (value) clipped[key] = value;
-	});
-	return Object.keys(clipped).length ? clipped : void 0;
-}
-function clipMetadata(metadata, maxKeys = MAX_METADATA_KEYS) {
-	if (!metadata || typeof metadata !== "object") return;
-	const clipped = {};
-	Object.entries(metadata).slice(0, maxKeys).forEach(([rawKey, rawValue]) => {
-		const key = sanitizeText(rawKey, 80);
-		if (!key || rawValue === void 0 || rawValue === null) return;
-		if (typeof rawValue === "boolean") {
-			clipped[key] = rawValue;
-			return;
-		}
-		if (typeof rawValue === "number") {
-			if (Number.isFinite(rawValue)) clipped[key] = rawValue;
-			return;
-		}
-		const value = clipText(rawValue, 240);
-		if (value) clipped[key] = value;
-	});
-	return Object.keys(clipped).length ? clipped : void 0;
-}
-function sanitizeStack(stack, options) {
-	if (!stack || options?.enabled === false) return;
-	return stack;
-}
-function getRawStack(error) {
-	if (error instanceof Error) return error.stack || error.message;
-}
-function sanitizeRequestId(value) {
-	if (!value) return;
-	return clipText(value, 240);
-}
-function sanitizeUrl(value) {
-	if (!value) return;
-	try {
-		const base = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
-		const parsedUrl = new URL(value, base);
-		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, 240);
-	}
-}
-function sanitizeRemote(remote) {
-	if (!remote || !remote.name) return;
-	return {
-		name: remote.name,
-		alias: sanitizeText(remote.alias, 120),
-		entry: clipText(remote.entry, 320),
-		entryGlobalName: sanitizeText(remote.entryGlobalName, 120),
-		type: sanitizeText(remote.type, 80)
-	};
-}
-function createRemoteInfo(remote) {
-	if (!remote?.name) return;
-	return {
-		name: remote.name,
-		alias: remote.alias,
-		entry: remote.entry,
-		entryGlobalName: remote.entryGlobalName,
-		type: remote.type
-	};
-}
-function isManifestUrl(value) {
-	const sanitized = sanitizeUrl(value);
-	return Boolean(sanitized && /manifest.*\.json$/i.test(sanitized));
-}
-function normalizeSharedScope(value) {
-	if (!value) return [];
-	return (Array.isArray(value) ? value : [value]).map((scope) => sanitizeText(scope, 120)).filter((scope) => Boolean(scope));
-}
-function getSharedScopes(shareInfo) {
-	return normalizeSharedScope(shareInfo?.scope).length ? normalizeSharedScope(shareInfo?.scope) : ["default"];
-}
-function getAvailableSharedVersions(args) {
-	const versions = /* @__PURE__ */ new Set();
-	const shareScopeMap = args.shareScopeMap || {};
-	getSharedScopes(args.shareInfo).forEach((scope) => {
-		Object.keys(shareScopeMap[scope]?.[args.pkgName] || {}).forEach((version) => {
-			versions.add(version);
-		});
-	});
-	return Array.from(versions);
-}
-function getSharedMissReason(args) {
-	if (!args.shareInfo) return "missing-config";
-	return getAvailableSharedVersions(args).length ? "version-mismatch" : "missing-provider";
-}
-function getSharedErrorReason(args) {
-	if (args.recovered) return getSharedMissReason(args);
-	const errorMessage = getErrorInfo(args.error, { enabled: false }).errorMessage || "";
-	if (!args.shareInfo || /Cannot find shared/i.test(errorMessage)) return "missing-config";
-	if (args.lifecycle === "loadShareSync" && typeof args.shareInfo.get === "function" && /RUNTIME-00[56]/.test(errorMessage)) return "sync-async-boundary";
-	if (args.lifecycle === "loadShareSync" && !args.shareInfo.get && /RUNTIME-006/.test(errorMessage)) return getSharedMissReason(args);
-	if (args.error) return "load-error";
-}
-function createSharedInfo(args, reason) {
-	const shareConfig = args.shareInfo?.shareConfig;
-	return {
-		name: args.pkgName,
-		shareScope: getSharedScopes(args.shareInfo),
-		requiredVersion: shareConfig?.requiredVersion,
-		selectedVersion: args.selectedShared?.version,
-		availableVersions: getAvailableSharedVersions(args),
-		provider: args.selectedShared?.from,
-		from: args.shareInfo?.from,
-		singleton: shareConfig?.singleton,
-		strictVersion: shareConfig?.strictVersion,
-		eager: shareConfig?.eager,
-		strategy: args.shareInfo?.strategy,
-		loaded: args.selectedShared?.loaded,
-		loading: Boolean(args.selectedShared?.loading) || void 0,
-		reason
-	};
-}
-function sanitizeShared(shared) {
-	if (!shared || !shared.name) return;
-	return {
-		name: sanitizeText(shared.name, 160) || "unknown",
-		shareScope: normalizeSharedScope(shared.shareScope),
-		requiredVersion: shared.requiredVersion === false ? false : sanitizeText(shared.requiredVersion, 120),
-		selectedVersion: sanitizeText(shared.selectedVersion, 120),
-		availableVersions: (shared.availableVersions || []).map((version) => sanitizeText(version, 120)).filter((version) => Boolean(version)).slice(0, 20),
-		provider: sanitizeText(shared.provider, 160),
-		from: sanitizeText(shared.from, 160),
-		singleton: shared.singleton,
-		strictVersion: shared.strictVersion,
-		eager: shared.eager,
-		strategy: sanitizeText(shared.strategy, 80),
-		loaded: shared.loaded,
-		loading: shared.loading,
-		reason: sanitizeText(shared.reason, 120)
-	};
-}
-function normalizeEventSource(value) {
-	return value === "runtime" || value === "business" ? value : void 0;
-}
-function extractErrorCode(value) {
-	const matched = String(value ?? "").match(ERROR_CODE_PATTERN)?.[0];
-	return matched ? sanitizeText(matched, 40) : void 0;
-}
-function getErrorInfo(error, stackTraceOptions) {
-	if (!error) return {};
-	if (error instanceof Error) return {
-		errorCode: extractErrorCode(`${error.name}\n${error.message}\n${error.stack || ""}`),
-		errorName: getRawText(error.name),
-		errorMessage: getRawText(error.message),
-		errorStack: sanitizeStack(error.stack, stackTraceOptions)
-	};
-	return {
-		errorCode: extractErrorCode(error),
-		errorMessage: getRawText(error)
-	};
-}
-function omitUndefinedFields(value) {
-	if (Array.isArray(value)) return value.map((item) => omitUndefinedFields(item));
-	if (!value || typeof value !== "object") return value;
-	const cleanValue = {};
-	Object.entries(value).forEach(([key, item]) => {
-		if (item === void 0) return;
-		cleanValue[key] = omitUndefinedFields(item);
-	});
-	return cleanValue;
-}
-function copyEvent(event) {
-	return omitUndefinedFields({
-		...event,
-		remote: event.remote ? { ...event.remote } : void 0,
-		shared: event.shared ? {
-			...event.shared,
-			shareScope: event.shared.shareScope ? [...event.shared.shareScope] : void 0,
-			availableVersions: event.shared.availableVersions ? [...event.shared.availableVersions] : void 0
-		} : void 0,
-		errorContext: event.errorContext ? { ...event.errorContext } : void 0,
-		metadata: event.metadata ? { ...event.metadata } : void 0
-	});
-}
-function copySummary(summary) {
-	return {
-		...summary,
-		phases: Object.entries(summary.phases).reduce((memo, [phase, phaseSummary]) => {
-			memo[phase] = { ...phaseSummary };
-			return memo;
-		}, {}),
-		shared: summary.shared ? {
-			...summary.shared,
-			shareScope: summary.shared.shareScope ? [...summary.shared.shareScope] : void 0
-		} : void 0,
-		flags: { ...summary.flags },
-		error: summary.error ? {
-			...summary.error,
-			context: summary.error.context ? { ...summary.error.context } : void 0
-		} : void 0
-	};
-}
-function copyFactReport(diagnosis) {
-	if (!diagnosis) return;
-	return {
-		...diagnosis,
-		facts: { ...diagnosis.facts },
-		completedPhases: [...diagnosis.completedPhases],
-		pendingPhases: [...diagnosis.pendingPhases],
-		warnings: diagnosis.warnings ? [...diagnosis.warnings] : void 0,
-		actions: diagnosis.actions.map((action) => ({ ...action }))
-	};
-}
-function copyModuleInfoSummary(moduleInfo) {
-	if (!moduleInfo) return;
-	return {
-		...moduleInfo,
-		entries: moduleInfo.entries.map((entry) => ({ ...entry })),
-		availableNames: moduleInfo.availableNames ? [...moduleInfo.availableNames] : void 0
-	};
-}
-function copyReport(report) {
-	return omitUndefinedFields({
-		...report,
-		remote: report.remote ? { ...report.remote } : void 0,
-		shared: report.shared ? {
-			...report.shared,
-			shareScope: report.shared.shareScope ? [...report.shared.shareScope] : void 0,
-			availableVersions: report.shared.availableVersions ? [...report.shared.availableVersions] : void 0
-		} : void 0,
-		errorContext: report.errorContext ? { ...report.errorContext } : void 0,
-		moduleInfo: copyModuleInfoSummary(report.moduleInfo),
-		events: report.events.map(copyEvent),
-		summary: copySummary(report.summary),
-		diagnosis: copyFactReport(report.diagnosis)
-	});
-}
-function getFederationGlobal() {
-	return globalThis.__FEDERATION__;
-}
-function normalizeScope(value) {
-	return sanitizeText(value, 120)?.replace(/[^\w:@.-]+/g, "-") || "default";
-}
-function shouldRecordEvent(level, event) {
-	if (level === "verbose") return true;
-	if (level === "summary") return event.status !== "start";
-	return event.status === "error" || Boolean(event.error);
-}
-function createTraceId(event) {
-	traceCounter += 1;
-	return `mf-${(event.remote?.name || event.phase || "runtime").replace(/[^a-z0-9]+/gi, "-").slice(0, 80)}-${Date.now().toString(36)}-${traceCounter.toString(36)}`;
-}
-function getPhaseDurationKey(event) {
-	const exposeKey = event.phase === "expose" || event.phase === "moduleFactory" ? event.expose || "" : "";
-	return [
-		event.traceId,
-		event.phase,
-		event.requestId || event.remote?.name || event.shared?.name || "",
-		exposeKey
-	].join("|");
-}
-function getRemoteEntryKey(remote) {
-	if (!remote?.name) return;
-	return [
-		remote.name,
-		remote.entryGlobalName || "",
-		remote.entry || ""
-	].join("|");
-}
-function getHostRemotesSummary(options) {
-	const remotes = (options?.remotes || []).map((remote) => clipText(remote.alias || remote.name || remote.entry, 120)).filter((remote) => Boolean(remote)).slice(0, 20);
-	return remotes.length ? remotes.join(",") : void 0;
-}
-function sanitizeModuleInfoPath(value) {
-	if (typeof value !== "string") return;
-	return clipText(value, 320);
-}
-function sanitizeModuleInfoGetPublicPath(value) {
-	if (typeof value !== "string") return;
-	return clipText(value, 500);
-}
-function sanitizeModuleInfoRemoteEntry(value) {
-	if (typeof value !== "string") return;
-	return clipText(value, 320);
-}
-function createClippedModuleInfoEntry(rawName, rawValue) {
-	const name = clipText(rawName, 240);
-	if (!name) return;
-	const value = isRecord(rawValue) ? rawValue : {};
-	return {
-		name,
-		publicPath: sanitizeModuleInfoPath(value["publicPath"]),
-		getPublicPath: sanitizeModuleInfoGetPublicPath(value["getPublicPath"]),
-		remoteEntry: sanitizeModuleInfoRemoteEntry(value["remoteEntry"]),
-		globalName: sanitizeText(value["globalName"], 160)
-	};
-}
-function normalizeModuleInfoLookupValue(value) {
-	if (typeof value !== "string" || !value) return;
-	return (/^https?:\/\//i.test(value) || value.startsWith("/") ? sanitizeUrl(value) : sanitizeText(value, 240))?.toLowerCase();
-}
-function getModuleInfoLookupValues(report) {
-	return new Set([
-		report.requestId?.split("/")[0],
-		report.remote?.name,
-		report.remote?.alias,
-		report.remote?.entry,
-		report.remote?.entryGlobalName,
-		report.sanitizedUrl,
-		report.errorContext?.["remoteName"],
-		report.errorContext?.["remoteAlias"],
-		report.errorContext?.["url"],
-		report.summary.error?.context?.["remoteName"],
-		report.summary.error?.context?.["remoteAlias"],
-		report.summary.error?.context?.["url"]
-	].map(normalizeModuleInfoLookupValue).filter((value) => Boolean(value)));
-}
-function matchesModuleInfoLookup(entry, lookupValues) {
-	if (!lookupValues.size) return false;
-	return [
-		entry.name,
-		entry.publicPath,
-		entry.getPublicPath,
-		entry.remoteEntry,
-		entry.globalName
-	].map(normalizeModuleInfoLookupValue).filter((value) => Boolean(value)).some((entryValue) => Array.from(lookupValues).some((lookupValue) => entryValue === lookupValue || entryValue.startsWith(`${lookupValue}:`) || entryValue.includes(`:${lookupValue}`) || lookupValue.startsWith("http") && entryValue.includes(lookupValue)));
-}
-function getModuleInfoCaptureReason(report) {
-	const text = [
-		report.errorCode,
-		report.errorName,
-		report.errorMessage,
-		report.summary.error?.errorCode,
-		report.summary.error?.errorName,
-		report.summary.error?.errorMessage,
-		...report.events.flatMap((event) => [
-			event.errorCode,
-			event.errorName,
-			event.errorMessage,
-			event.message,
-			event.lifecycle
-		])
-	].join("\n");
-	if (/RUNTIME-007/.test(text)) return "remote-snapshot";
-	if (/RUNTIME-011/.test(text)) return "remote-entry-missing-in-snapshot";
-	if (/moduleInfo|module info/i.test(text)) return "module-info";
-	if (/remote snapshot|global snapshot|snapshot/i.test(text)) return "remote-snapshot";
-}
-function createModuleInfoSummary(report) {
-	const reason = getModuleInfoCaptureReason(report);
-	if (!reason) return;
-	const moduleInfo = getFederationGlobal()?.moduleInfo;
-	const rawEntries = isRecord(moduleInfo) ? Object.entries(moduleInfo) : [];
-	const clippedEntries = rawEntries.map(([name, value]) => createClippedModuleInfoEntry(name, value)).filter((entry) => Boolean(entry));
-	const lookupValues = getModuleInfoLookupValues(report);
-	const matchedEntries = clippedEntries.filter((entry) => matchesModuleInfoLookup(entry, lookupValues));
-	return {
-		reason,
-		clipped: true,
-		totalCount: rawEntries.length,
-		matchedCount: matchedEntries.length,
-		entries: matchedEntries.slice(0, MAX_MODULE_INFO_ENTRIES),
-		availableNames: matchedEntries.length ? void 0 : clippedEntries.map((entry) => entry.name).slice(0, MAX_MODULE_INFO_ENTRIES)
-	};
-}
-function getResourceErrorType(event) {
-	const text = `${event.errorMessage || ""}\n${event.message || ""}`;
-	if (!event.errorCode && !text) return;
-	if (/ScriptExecutionError/i.test(text)) return "script-execution";
-	if (/timeout|timed out/i.test(text)) return "timeout";
-	if (/ScriptNetworkError|NetworkError|Failed to fetch|Request failed|ERR_|404|CORS/i.test(text)) return "network";
-	return event.errorCode === "RUNTIME-008" ? "unknown" : void 0;
-}
-function getOwnerHint(event) {
-	const resourceErrorType = getResourceErrorType(event);
-	switch (event.errorCode) {
-		case "RUNTIME-001":
-		case "RUNTIME-002":
-		case "RUNTIME-011":
-		case "RUNTIME-013":
-		case "RUNTIME-014":
-		case "RUNTIME-015": return "remote";
-		case "RUNTIME-003":
-		case "RUNTIME-004":
-		case "RUNTIME-007": return "host";
-		case "RUNTIME-005":
-		case "RUNTIME-006":
-		case "RUNTIME-012": return "shared";
-		case "RUNTIME-008": return resourceErrorType === "network" || resourceErrorType === "timeout" ? "network" : "remote";
-		default:
-			if (event.shared) return "shared";
-			if (event.remote) return "remote";
-			if (event.phase === "manifest" || event.phase === "matchRemote") return "host";
-			return event.errorCode ? "runtime" : void 0;
-	}
-}
-function getRetryable(event) {
-	const resourceErrorType = getResourceErrorType(event);
-	if (event.errorCode === "RUNTIME-008") return resourceErrorType === "network" || resourceErrorType === "timeout";
-	if (event.errorCode === "RUNTIME-003") {
-		const text = `${event.errorMessage || ""}\n${event.message || ""}`;
-		return /NetworkError|Failed to fetch|Request failed|timeout|timed out/i.test(text);
-	}
-	if (event.errorCode && [
-		"RUNTIME-001",
-		"RUNTIME-002",
-		"RUNTIME-004",
-		"RUNTIME-005",
-		"RUNTIME-006",
-		"RUNTIME-011",
-		"RUNTIME-012",
-		"RUNTIME-013",
-		"RUNTIME-014",
-		"RUNTIME-015"
-	].includes(event.errorCode)) return false;
-}
-function createErrorContext(event, inputContext) {
-	const context = { ...inputContext };
-	if (event.lifecycle) context.lifecycle = event.lifecycle;
-	if (event.requestId) context.requestId = event.requestId;
-	if (event.remote?.name) context.remoteName = event.remote.name;
-	if (event.remote?.alias) context.remoteAlias = event.remote.alias;
-	if (event.remote?.type) context.remoteType = event.remote.type;
-	if (event.remote?.entryGlobalName) context.entryGlobalName = event.remote.entryGlobalName;
-	if (event.sanitizedUrl) context.url = event.sanitizedUrl;
-	if (event.expose) context.expose = event.expose;
-	if (event.shared?.name) context.shareName = event.shared.name;
-	if (event.shared?.requiredVersion) context.requiredVersion = event.shared.requiredVersion;
-	if (event.shared?.selectedVersion) context.selectedVersion = event.shared.selectedVersion;
-	if (event.shared?.provider) context.provider = event.shared.provider;
-	const resourceErrorType = getResourceErrorType(event);
-	if (resourceErrorType) context.resourceErrorType = resourceErrorType;
-	return clipObservabilityMetadata(context);
-}
-function ObservabilityPlugin(options = {}) {
-	const level = options.level || "summary";
-	const configuredMaxEvents = normalizeMaxEvents(options.maxEvents, DEFAULT_MAX_EVENTS);
-	const events = [];
-	const reports = /* @__PURE__ */ new Map();
-	const traceByRequest = /* @__PURE__ */ new Map();
-	const traceByRemote = /* @__PURE__ */ new Map();
-	const phaseStartTimes = /* @__PURE__ */ new Map();
-	const seenManifestUrls = /* @__PURE__ */ new Set();
-	const seenRemoteEntryKeys = /* @__PURE__ */ new Set();
-	const consoleReportedTraceIds = /* @__PURE__ */ new Set();
-	let latestTraceId;
-	let runtimeObservabilityEnabled = false;
-	let effectiveMaxEvents = configuredMaxEvents;
-	let browserGlobalScope;
-	let lastRuntimeOrigin;
-	const isEnabled = () => {
-		if (options.enabled === false) return false;
-		runtimeObservabilityEnabled = true;
-		return true;
-	};
-	const resolveTraceId = (event) => {
-		const sanitizedRequestId = sanitizeRequestId(event.requestId);
-		if (event.traceId && reports.has(event.traceId)) return event.traceId;
-		if (event.status === "start" && event.phase === "loadRemote") {
-			const traceId = event.traceId || createTraceId(event);
-			if (sanitizedRequestId) traceByRequest.set(sanitizedRequestId, traceId);
-			if (event.remote?.name) traceByRemote.set(event.remote.name, traceId);
-			return traceId;
-		}
-		if (sanitizedRequestId) {
-			const traceId = traceByRequest.get(sanitizedRequestId);
-			if (traceId) return traceId;
-		}
-		if (event.remote?.name) {
-			const traceId = traceByRemote.get(event.remote.name);
-			if (traceId) return traceId;
-		}
-		return event.traceId || createTraceId(event);
-	};
-	const normalizeEvent = (event, traceId, origin) => {
-		const errorInfo = getErrorInfo(event.error, options.stackTrace);
-		const sanitizedRemote = sanitizeRemote(event.remote);
-		const sanitizedShared = sanitizeShared(event.shared);
-		const hostName = sanitizeText(event.hostName, 120) || sanitizeText(origin?.options?.name, 120);
-		const message = getRawText(event.message) || errorInfo.errorMessage;
-		const normalizedEvent = {
-			traceId,
-			timestamp: event.timestamp || Date.now(),
-			phase: sanitizeText(event.phase, 120) || "runtime",
-			status: event.status,
-			requestId: sanitizeRequestId(event.requestId),
-			hostName,
-			remote: sanitizedRemote,
-			shared: sanitizedShared,
-			expose: sanitizeText(event.expose, 240),
-			sanitizedUrl: clipText(event.url || event.remote?.entry, 320),
-			message,
-			errorCode: errorInfo.errorCode,
-			errorName: errorInfo.errorName,
-			errorMessage: errorInfo.errorMessage,
-			errorStack: errorInfo.errorStack,
-			duration: typeof event.duration === "number" && Number.isFinite(event.duration) ? Math.max(0, event.duration) : void 0,
-			lifecycle: sanitizeText(event.lifecycle, 120),
-			eventName: sanitizeText(event.eventName, 160),
-			source: normalizeEventSource(event.source),
-			recovered: event.recovered === true || void 0,
-			cached: event.cached === true || void 0,
-			componentName: sanitizeText(event.componentName, 160),
-			metadata: clipObservabilityMetadata(event.metadata)
-		};
-		if (normalizedEvent.status === "error" || event.error) {
-			normalizedEvent.ownerHint = getOwnerHint(normalizedEvent);
-			normalizedEvent.retryable = getRetryable(normalizedEvent);
-			normalizedEvent.errorContext = createErrorContext(normalizedEvent, event.errorContext);
-		}
-		return normalizedEvent;
-	};
-	const applyPhaseDuration = (event) => {
-		const key = getPhaseDurationKey(event);
-		if (event.status === "start") {
-			phaseStartTimes.set(key, event.timestamp);
-			return;
-		}
-		if (event.duration !== void 0) return;
-		const startedAt = phaseStartTimes.get(key);
-		if (startedAt === void 0) return;
-		event.duration = Math.max(0, event.timestamp - startedAt);
-		phaseStartTimes.delete(key);
-	};
-	const updateTraceMaps = (event) => {
-		if (event.requestId) traceByRequest.set(event.requestId, event.traceId);
-		if (event.remote?.name) traceByRemote.set(event.remote.name, event.traceId);
-	};
-	const trimEvents = (report) => {
-		while (events.length > effectiveMaxEvents) events.shift();
-		while (report.events.length > effectiveMaxEvents) report.events.shift();
-	};
-	const getEventOutcome = (event) => {
-		if (event.status === "success") return "success";
-		if (event.status === "error") return "error";
-		if (event.status === "complete") {
-			if (event.recovered) return "recovered";
-			if (event.errorName || event.errorMessage) return "error";
-		}
-	};
-	const isLoadRemoteCompleteEvent = (event) => event.phase === "loadRemote" && event.status === "complete";
-	const isRuntimeLoadedEvent = (event) => event.phase === "loadRemote" && (event.status === "success" || event.status === "complete" && event.recovered);
-	const isComponentLoadedEvent = (event) => event.status === "success" && (event.eventName === COMPONENT_BUSINESS_LOADED_EVENT || event.phase === "component" && event.message === COMPONENT_BUSINESS_LOADED_EVENT);
-	const shouldReplaceFailedPhase = (report, event) => {
-		if (isLoadRemoteCompleteEvent(event) && report.failedPhase) return false;
-		if (!report.failedPhase) return true;
-		return report.failedPhase === "loadRemote" && event.phase !== "loadRemote";
-	};
-	const createEmptyPhaseCollection = () => ({
-		phases: {},
-		flags: {
-			cached: false,
-			retried: false,
-			fallback: false,
-			recovered: false
-		}
-	});
-	const createPhaseCollection = (eventsForReport) => {
-		const collection = createEmptyPhaseCollection();
-		eventsForReport.forEach((event) => {
-			const phase = event.phase;
-			const phaseSummary = collection.phases[phase] || { status: event.status };
-			if (event.status !== "start") phaseSummary.status = event.status;
-			if (event.duration !== void 0) phaseSummary.duration = event.duration;
-			if (event.cached) {
-				phaseSummary.cached = true;
-				collection.flags.cached = true;
-			}
-			if (event.recovered) {
-				phaseSummary.recovered = true;
-				collection.flags.recovered = true;
-			}
-			if (event.lifecycle) phaseSummary.lifecycle = event.lifecycle;
-			collection.phases[phase] = phaseSummary;
-			if (event.phase === "remoteEntry" && event.recovered) collection.flags.retried = true;
-			if (event.phase === "loadRemote" && event.status === "complete" && event.recovered) collection.flags.fallback = true;
-			if (event.shared?.selectedVersion || event.shared?.provider) collection.shared = {
-				name: event.shared.name,
-				provider: event.shared.provider,
-				selectedVersion: event.shared.selectedVersion,
-				shareScope: event.shared.shareScope ? [...event.shared.shareScope] : void 0
-			};
-		});
-		return collection;
-	};
-	const createErrorSummary = (eventsForReport, failedPhase) => {
-		const errorEvent = eventsForReport.find((event) => event.status === "error" && event.phase === failedPhase) || eventsForReport.find((event) => event.status === "error") || eventsForReport.find((event) => event.status === "complete" && event.errorMessage);
-		if (!errorEvent) return;
-		return {
-			errorCode: errorEvent.errorCode,
-			errorName: errorEvent.errorName,
-			errorMessage: errorEvent.errorMessage,
-			failedPhase: failedPhase || errorEvent.phase,
-			lifecycle: errorEvent.lifecycle,
-			ownerHint: errorEvent.ownerHint,
-			retryable: errorEvent.retryable,
-			context: errorEvent.errorContext ? { ...errorEvent.errorContext } : void 0
-		};
-	};
-	const createReportSummary = (report) => {
-		const loadCompleted = report.events.some(isLoadRemoteCompleteEvent);
-		const runtimeLoaded = report.events.some(isRuntimeLoadedEvent);
-		const recovered = report.events.some((item) => item.recovered);
-		const componentLoaded = report.events.some(isComponentLoadedEvent);
-		const lastEvent = report.events[report.events.length - 1];
-		let outcome = "pending";
-		if (componentLoaded) outcome = "component-loaded";
-		else if (recovered && runtimeLoaded) outcome = "recovered";
-		else if (report.status === "error") outcome = "failed";
-		else if (runtimeLoaded) outcome = "runtime-loaded";
-		const phaseCollection = createPhaseCollection(report.events);
-		return {
-			eventCount: report.events.length,
-			recovered,
-			loadCompleted,
-			runtimeLoaded,
-			componentLoaded,
-			outcome,
-			lastPhase: lastEvent?.phase,
-			phases: phaseCollection.phases,
-			shared: phaseCollection.shared,
-			flags: phaseCollection.flags,
-			error: createErrorSummary(report.events, report.failedPhase)
-		};
-	};
-	const refreshModuleInfoSummary = (report) => {
-		const moduleInfo = createModuleInfoSummary(report);
-		if (moduleInfo) report.moduleInfo = moduleInfo;
-	};
-	const getReportContext = (report) => report.summary.error?.context || report.errorContext;
-	const getContextText = (context, key) => {
-		const value = context?.[key];
-		return typeof value === "string" && value ? value : void 0;
-	};
-	const getDiagnosisOwnerHint = (report) => report.summary.error?.ownerHint || report.ownerHint || (report.shared ? "shared" : report.remote ? "remote" : "unknown");
-	const getDiagnosisResourceErrorType = (report) => getContextText(getReportContext(report), "resourceErrorType") || getResourceErrorType({
-		errorCode: report.errorCode,
-		errorMessage: report.errorMessage,
-		message: report.events.at(-1)?.message,
-		lifecycle: report.summary.error?.lifecycle
-	});
-	const getDiagnosisDocLink = (report) => {
-		const matched = [
-			report.errorMessage,
-			report.errorStack,
-			...report.events.flatMap((event) => [
-				event.errorMessage,
-				event.errorStack,
-				event.message
-			])
-		].filter((item) => Boolean(item)).join("\n").match(DIAGNOSTIC_DOC_LINK_PATTERN)?.[0];
-		const docLink = sanitizeText(matched, 240);
-		if (docLink) return docLink;
-		return report.errorCode?.startsWith("RUNTIME-") ? RUNTIME_DOC_LINK : void 0;
-	};
-	const getDiagnosisTitle = (report) => {
-		if (report.status !== "error") {
-			if (report.summary.componentLoaded) return "Business component loaded";
-			if (report.summary.runtimeLoaded) return "Remote loaded successfully";
-			return "Remote loading is pending";
-		}
-		switch (report.errorCode) {
-			case "RUNTIME-001": return "Remote entry global was not registered";
-			case "RUNTIME-003": return "Manifest could not be loaded";
-			case "RUNTIME-004": return "Remote was not found in host remotes";
-			case "RUNTIME-007": return "Deployment moduleInfo did not match the requested remote";
-			case "RUNTIME-013": return "Manifest is not a valid Module Federation manifest";
-			case "RUNTIME-014": return "Requested expose was not found in the remote";
-			case "RUNTIME-015": return "Remote container initialization failed";
-			case "RUNTIME-005":
-			case "RUNTIME-006": return "Shared dependency could not be resolved";
-			case "RUNTIME-008": {
-				const resourceErrorType = getDiagnosisResourceErrorType(report);
-				if (resourceErrorType === "network") return "Remote entry failed because of a network error";
-				if (resourceErrorType === "timeout") return "Remote entry request timed out";
-				if (resourceErrorType === "script-execution") return "Remote entry loaded but failed during execution";
-				return "Remote entry resource could not be loaded";
-			}
-			default:
-				if (report.failedPhase === "shared" || report.shared) return "Shared dependency could not be resolved";
-				return report.failedPhase ? `Module Federation failed at ${report.failedPhase}` : "Module Federation loading failed";
-		}
-	};
-	const getCompletedPhases = (report) => Array.from(new Set(report.events.filter((event) => event.status === "success" || event.status === "complete").map((event) => event.phase)));
-	const getPendingPhases = (report) => {
-		const started = /* @__PURE__ */ new Set();
-		const ended = /* @__PURE__ */ new Set();
-		report.events.forEach((event) => {
-			if (event.status === "start") {
-				started.add(event.phase);
-				return;
-			}
-			ended.add(event.phase);
-		});
-		return Array.from(started).filter((phase) => !ended.has(phase));
-	};
-	const createDiagnosisFacts = (report, ownerHint) => {
-		const context = getReportContext(report);
-		const facts = {};
-		const addFact = (key, value) => {
-			if (value === void 0 || value === null || value === "") return;
-			facts[key] = Array.isArray(value) ? value.join(",") : value;
-		};
-		addFact("traceId", report.traceId);
-		addFact("status", report.status);
-		addFact("outcome", report.summary.outcome);
-		addFact("errorCode", report.errorCode || report.summary.error?.errorCode);
-		addFact("failedPhase", report.failedPhase || report.summary.error?.failedPhase);
-		addFact("lifecycle", report.summary.error?.lifecycle);
-		addFact("ownerHint", ownerHint);
-		addFact("retryable", report.retryable ?? report.summary.error?.retryable);
-		addFact("requestId", report.requestId);
-		addFact("hostName", report.hostName);
-		addFact("remoteName", report.remote?.name);
-		addFact("remoteAlias", report.remote?.alias);
-		addFact("remoteEntry", report.remote?.entry);
-		addFact("entryGlobalName", report.remote?.entryGlobalName);
-		addFact("remoteType", report.remote?.type);
-		addFact("url", report.sanitizedUrl || getContextText(context, "url"));
-		addFact("expose", report.expose);
-		addFact("hostRemotes", getContextText(context, "hostRemotes"));
-		addFact("resourceErrorType", getDiagnosisResourceErrorType(report));
-		addFact("shareName", report.shared?.name);
-		addFact("shareScope", report.shared?.shareScope);
-		addFact("requiredVersion", report.shared?.requiredVersion);
-		addFact("selectedVersion", report.shared?.selectedVersion);
-		addFact("availableVersions", report.shared?.availableVersions);
-		addFact("provider", report.shared?.provider);
-		addFact("sharedFrom", report.shared?.from);
-		addFact("singleton", report.shared?.singleton);
-		addFact("strictVersion", report.shared?.strictVersion);
-		addFact("eager", report.shared?.eager);
-		addFact("sharedReason", report.shared?.reason);
-		addFact("componentName", report.events.find(isComponentLoadedEvent)?.componentName);
-		addFact("moduleInfoReason", report.moduleInfo?.reason);
-		addFact("moduleInfoTotalCount", report.moduleInfo?.totalCount);
-		addFact("moduleInfoMatchedCount", report.moduleInfo?.matchedCount);
-		addFact("moduleInfoNames", report.moduleInfo?.entries.length ? report.moduleInfo.entries.map((entry) => entry.name) : report.moduleInfo?.availableNames);
-		addFact("cached", report.summary.flags.cached);
-		addFact("retried", report.summary.flags.retried);
-		addFact("fallback", report.summary.flags.fallback);
-		addFact("recovered", report.summary.recovered);
-		addFact("loadCompleted", report.summary.loadCompleted);
-		addFact("runtimeLoaded", report.summary.runtimeLoaded);
-		addFact("componentLoaded", report.summary.componentLoaded);
-		return clipMetadata(facts, MAX_FACT_KEYS) || {};
-	};
-	const createDiagnosisWarnings = (report) => {
-		const warnings = [];
-		if (report.status === "error" && !report.errorCode) warnings.push("No known Module Federation error code was captured");
-		if (report.summary.flags.retried) warnings.push("Remote entry loading recovered after retry");
-		if (report.summary.flags.fallback) warnings.push("Remote loading completed through fallback recovery");
-		if (report.summary.runtimeLoaded && !report.summary.componentLoaded) warnings.push("Business component readiness signal was not recorded");
-		if (report.moduleInfo && report.moduleInfo.matchedCount === 0) warnings.push("No matching clipped moduleInfo entry was found for the failed remote");
-		return warnings;
-	};
-	const createDiagnosisActions = (report, ownerHint) => {
-		const actions = [];
-		const pushAction = (id, title, hint = ownerHint, detail) => {
-			actions.push({
-				id,
-				ownerHint: hint,
-				title,
-				detail
-			});
-		};
-		if (report.status !== "error" && !report.summary.error) return actions;
-		switch (report.errorCode) {
-			case "RUNTIME-001":
-				pushAction("check-remote-global", "Check the remote global name against the remoteEntry build output", "remote");
-				pushAction("check-remote-entry", "Check that remoteEntry registers the expected container", "remote");
-				break;
-			case "RUNTIME-003":
-				pushAction("check-manifest-url", "Check the manifest URL and manifest JSON response", "host");
-				pushAction("check-network", "Check network availability, CORS, and timeout for the manifest", "network");
-				break;
-			case "RUNTIME-013":
-				pushAction("check-manifest-url", "Check that the manifest response is valid Module Federation JSON", "remote");
-				break;
-			case "RUNTIME-004":
-				pushAction("check-host-remotes", "Check that the requested remote exists in host remotes", "host");
-				break;
-			case "RUNTIME-007":
-				pushAction("check-module-info", "Check deployment-provided __FEDERATION__.moduleInfo for the requested remote", "host");
-				pushAction("check-host-remotes", "Check that the runtime remote name or alias matches moduleInfo", "host");
-				break;
-			case "RUNTIME-014":
-				pushAction("check-expose", "Check that the requested expose exists in the remote build output", "remote");
-				break;
-			case "RUNTIME-015":
-				pushAction("check-remote-entry", "Check the error thrown during remoteEntry init", "remote");
-				pushAction("check-shared-provider", "Check share scope initialization data passed to the remote", "shared");
-				break;
-			case "RUNTIME-005":
-			case "RUNTIME-006":
-				pushAction("check-shared-provider", "Check that a compatible shared provider is available", "shared");
-				pushAction("check-shared-version", "Compare requested shared version with available versions", "shared");
-				if (report.summary.error?.lifecycle === "loadShareSync" || report.shared?.reason === "sync-async-boundary" || report.shared?.eager === false) pushAction("check-eager-config", "Check eager configuration or add an async boundary before sync shared consumption", "shared");
-				break;
-			case "RUNTIME-008": {
-				const resourceErrorType = getDiagnosisResourceErrorType(report);
-				if (resourceErrorType === "network" || resourceErrorType === "timeout") pushAction("check-network", "Check remoteEntry URL, CORS, status code, and timeout", "network");
-				pushAction("check-remote-entry", resourceErrorType === "script-execution" ? "Check remoteEntry execution errors in the remote build output" : "Check that remoteEntry is reachable and serves JavaScript", resourceErrorType === "network" || resourceErrorType === "timeout" ? "network" : "remote");
-				break;
-			}
-			default:
-				if (report.failedPhase === "manifest") pushAction("check-manifest-url", "Check manifest loading and parsing", "host");
-				if (report.failedPhase === "remoteEntry") pushAction("check-remote-entry", "Check remoteEntry loading and initialization", "remote");
-				if (report.failedPhase === "expose") pushAction("check-expose", "Check that the requested expose exists in the remote", "remote");
-				if (report.failedPhase === "shared") {
-					pushAction("check-shared-provider", "Check shared dependency resolution", "shared");
-					if (report.shared?.requiredVersion !== void 0 || report.shared?.availableVersions?.length || report.shared?.reason === "version-mismatch") pushAction("check-shared-version", "Compare requested shared version with available versions", "shared");
-					if (report.summary.error?.lifecycle === "loadShareSync" || report.shared?.reason === "sync-async-boundary" || report.shared?.eager === false) pushAction("check-eager-config", "Check eager configuration or add an async boundary before sync shared consumption", "shared");
-				}
-		}
-		if (report.moduleInfo && !actions.some((action) => action.id === "check-module-info")) pushAction("check-module-info", "Check deployment-provided __FEDERATION__.moduleInfo for the requested remote", "host");
-		if (!actions.length) pushAction("inspect-runtime-events", "Inspect the ordered observability events for the failed phase", ownerHint);
-		return actions;
-	};
-	const createFactReport = (report) => {
-		const ownerHint = getDiagnosisOwnerHint(report);
-		const warnings = createDiagnosisWarnings(report);
-		return {
-			title: getDiagnosisTitle(report),
-			outcome: report.summary.outcome,
-			status: report.status,
-			ownerHint,
-			failedPhase: report.failedPhase || report.summary.error?.failedPhase,
-			errorCode: report.errorCode || report.summary.error?.errorCode,
-			errorName: report.errorName || report.summary.error?.errorName,
-			errorMessage: report.errorMessage || report.summary.error?.errorMessage,
-			docLink: getDiagnosisDocLink(report),
-			facts: createDiagnosisFacts(report, ownerHint),
-			completedPhases: getCompletedPhases(report),
-			pendingPhases: getPendingPhases(report),
-			warnings: warnings.length ? warnings : void 0,
-			actions: createDiagnosisActions(report, ownerHint)
-		};
-	};
-	const refreshReportDerivedFields = (report) => {
-		report.summary = createReportSummary(report);
-		refreshModuleInfoSummary(report);
-		report.diagnosis = createFactReport(report);
-	};
-	const updateReport = (event) => {
-		let report = reports.get(event.traceId);
-		if (!report) {
-			report = {
-				traceId: event.traceId,
-				status: event.status === "error" ? "error" : "pending",
-				requestId: event.requestId,
-				hostName: event.hostName,
-				remote: event.remote ? { ...event.remote } : void 0,
-				shared: event.shared ? copyEvent(event).shared : void 0,
-				expose: event.expose,
-				sanitizedUrl: event.sanitizedUrl,
-				startedAt: event.timestamp,
-				updatedAt: event.timestamp,
-				duration: 0,
-				failedPhase: event.status === "error" ? event.phase : void 0,
-				errorCode: event.errorCode,
-				errorName: event.errorName,
-				errorMessage: event.errorMessage,
-				errorStack: event.errorStack,
-				ownerHint: event.ownerHint,
-				retryable: event.retryable,
-				errorContext: event.errorContext ? { ...event.errorContext } : void 0,
-				events: [],
-				summary: {
-					eventCount: 0,
-					recovered: false,
-					loadCompleted: false,
-					runtimeLoaded: false,
-					componentLoaded: false,
-					outcome: "pending",
-					lastPhase: void 0,
-					phases: {},
-					shared: void 0,
-					flags: createEmptyPhaseCollection().flags,
-					error: void 0
-				}
-			};
-			reports.set(event.traceId, report);
-		}
-		if (event.requestId) report.requestId = event.requestId;
-		if (event.hostName) report.hostName = event.hostName;
-		if (event.remote) report.remote = { ...event.remote };
-		if (event.shared) report.shared = copyEvent(event).shared;
-		if (event.expose) report.expose = event.expose;
-		if (event.sanitizedUrl) report.sanitizedUrl = event.sanitizedUrl;
-		if (event.errorStack) report.errorStack = event.errorStack;
-		if (event.errorCode) report.errorCode = event.errorCode;
-		if (event.errorName) report.errorName = event.errorName;
-		if (event.errorMessage) report.errorMessage = event.errorMessage;
-		if (event.ownerHint) report.ownerHint = event.ownerHint;
-		if (event.retryable !== void 0) report.retryable = event.retryable;
-		if (event.errorContext) report.errorContext = { ...event.errorContext };
-		report.events.push(event);
-		report.updatedAt = event.timestamp;
-		report.duration = Math.max(0, report.updatedAt - report.startedAt);
-		const eventOutcome = getEventOutcome(event);
-		if (eventOutcome === "error") {
-			report.status = "error";
-			if (shouldReplaceFailedPhase(report, event)) report.failedPhase = event.phase;
-		} else if (eventOutcome === "recovered") report.status = "success";
-		else if (eventOutcome === "success" && report.status !== "error") report.status = "success";
-		refreshReportDerivedFields(report);
-		latestTraceId = event.traceId;
-		trimEvents(report);
-		return report;
-	};
-	const notifyEvent = (event, report, origin) => {
-		try {
-			options.onEvent?.(copyEvent(event), copyReport(report), { origin });
-		} catch {}
-	};
-	const notifyReport = (report, origin) => {
-		if (report.events[report.events.length - 1]?.status === "start") return;
-		try {
-			options.onReport?.(copyReport(report), { origin });
-		} catch {}
-	};
-	const notifyRawError = (errorValue, event, report, origin) => {
-		if (!errorValue || !options.onRawError) return;
-		try {
-			options.onRawError(errorValue, {
-				origin,
-				event: copyEvent(event),
-				report: copyReport(report)
-			});
-		} catch {}
-	};
-	const getEventsSnapshot = () => events.map(copyEvent);
-	const getTraceIdsSnapshot = () => Array.from(reports.keys());
-	const getReportTimeline = () => Array.from(reports.values()).sort((left, right) => {
-		if (right.updatedAt !== left.updatedAt) return right.updatedAt - left.updatedAt;
-		return right.startedAt - left.startedAt;
-	});
-	const matchesReportValue = (value, expected) => {
-		if (!value || !expected) return false;
-		const normalizedValue = value.toLowerCase();
-		const normalizedExpected = expected.toLowerCase();
-		return normalizedValue === normalizedExpected || normalizedValue.includes(normalizedExpected);
-	};
-	const matchesReportQuery = (report, query) => {
-		if (query.traceId && report.traceId !== query.traceId) return false;
-		if (query.status && report.status !== query.status) return false;
-		if (query.outcome && report.summary.outcome !== query.outcome) return false;
-		if (query.remote && ![
-			report.remote?.name,
-			report.remote?.alias,
-			report.remote?.entry,
-			report.requestId,
-			report.sanitizedUrl
-		].some((value) => matchesReportValue(value, query.remote))) return false;
-		if (query.expose && ![report.expose, report.requestId].some((value) => matchesReportValue(value, query.expose))) return false;
-		if (query.shared && ![report.shared?.name].some((value) => matchesReportValue(value, query.shared))) return false;
-		return true;
-	};
-	const getReportsSnapshot = (options = {}) => {
-		const limit = normalizeQueryLimit(options.limit);
-		const timeline = getReportTimeline();
-		return (limit ? timeline.slice(0, limit) : timeline).map(copyReport);
-	};
-	const findReportsSnapshot = (query = {}) => {
-		const limit = normalizeQueryLimit(query.limit);
-		const matchedReports = getReportTimeline().filter((report) => matchesReportQuery(report, query));
-		return (limit ? matchedReports.slice(0, limit) : matchedReports).map(copyReport);
-	};
-	const getLatestReportSnapshot = () => {
-		if (!latestTraceId) return;
-		const report = reports.get(latestTraceId);
-		return report ? copyReport(report) : void 0;
-	};
-	const getReportSnapshot = (traceId) => {
-		const report = reports.get(traceId);
-		return report ? copyReport(report) : void 0;
-	};
-	const exportReportSnapshot = (traceId) => traceId ? getReportSnapshot(traceId) : getLatestReportSnapshot();
-	const createBrowserReader = () => ({
-		getEvents: getEventsSnapshot,
-		getTraceIds: getTraceIdsSnapshot,
-		getReports: getReportsSnapshot,
-		findReports: findReportsSnapshot,
-		getLatestReport: getLatestReportSnapshot,
-		getReport: getReportSnapshot,
-		exportReport: exportReportSnapshot
-	});
-	const shouldExposeBrowserGlobal = () => options.browser?.enabled === true;
-	const ensureBrowserGlobal = (origin) => {
-		if (!shouldExposeBrowserGlobal()) return;
-		const federationGlobal = getFederationGlobal();
-		if (!federationGlobal) return;
-		const scope = normalizeScope(options.browser?.scope || origin?.options?.name || "default");
-		const reader = createBrowserReader();
-		const readers = federationGlobal.__OBSERVABILITY__ || {};
-		federationGlobal.__OBSERVABILITY__ = readers;
-		browserGlobalScope = scope;
-		try {
-			Object.defineProperty(readers, scope, {
-				value: reader,
-				configurable: true,
-				enumerable: true
-			});
-		} catch {
-			readers[scope] = reader;
-		}
-	};
-	const shouldUseConsole = () => options.console !== false;
-	const shouldUseMinimalBrowserConsole = () => options.browser?.mode === "production";
-	const getBrowserReadCommand = (traceId) => {
-		if (!browserGlobalScope) return;
-		return `window.__FEDERATION__.__OBSERVABILITY__[${JSON.stringify(browserGlobalScope)}].getReport(${JSON.stringify(traceId)})`;
-	};
-	const emitConsoleHint = (event, report, rawError) => {
-		if (getEventOutcome(event) !== "error" || !shouldUseConsole() || consoleReportedTraceIds.has(report.traceId)) return;
-		consoleReportedTraceIds.add(report.traceId);
-		if (shouldUseMinimalBrowserConsole()) {
-			const lines = ["[Module Federation] Observability report generated", `traceId: ${report.traceId}`];
-			if (report.errorCode) lines.push(`errorCode: ${report.errorCode}`);
-			try {
-				console.error(lines.join("\n"));
-			} catch {}
-			return;
-		}
-		const lines = [
-			"[Module Federation] Observability report generated",
-			`traceId: ${report.traceId}`,
-			`phase: ${report.failedPhase || event.phase}`
-		];
-		if (report.requestId) lines.push(`requestId: ${report.requestId}`);
-		if (report.errorCode) lines.push(`errorCode: ${report.errorCode}`);
-		if (report.shared?.name) lines.push(`shared: ${report.shared.name}`);
-		const browserReadCommand = getBrowserReadCommand(report.traceId);
-		if (browserReadCommand) lines.push(`read: ${browserReadCommand}`);
-		else lines.push(`read: observability.getReport(${JSON.stringify(report.traceId)})`);
-		const rawStack = getRawStack(rawError);
-		if (options.printRawStack === true && rawStack) lines.push("rawStack:", rawStack);
-		try {
-			console.error(lines.join("\n"));
-		} catch {}
-	};
-	const prepareOutputChannels = (origin) => {
-		browserGlobalScope = void 0;
-		ensureBrowserGlobal(origin);
-	};
-	const prepareRuntimeOrigin = (origin) => {
-		if (!isEnabled()) return false;
-		lastRuntimeOrigin = origin;
-		prepareOutputChannels(origin);
-		return true;
-	};
-	const recordEvent = (input, origin) => {
-		const event = normalizeEvent(input, resolveTraceId(input), origin);
-		applyPhaseDuration(event);
-		updateTraceMaps(event);
-		if (!shouldRecordEvent(level, input)) return;
-		events.push(event);
-		const report = updateReport(event);
-		emitConsoleHint(event, report, input.error);
-		notifyRawError(input.error, event, report, origin);
-		notifyEvent(event, report, origin);
-		notifyReport(report, origin);
-		return event;
-	};
-	return {
-		plugin: {
-			name: "observability-plugin",
-			beforeRequest(args) {
-				const requestArgs = args;
-				if (!prepareRuntimeOrigin(requestArgs.origin)) return;
-				recordEvent({
-					phase: "loadRemote",
-					status: "start",
-					requestId: requestArgs.id,
-					lifecycle: "beforeRequest",
-					message: "remote:load-start"
-				}, requestArgs.origin);
-			},
-			afterMatchRemote(args) {
-				const matchArgs = args;
-				if (!prepareRuntimeOrigin(matchArgs.origin)) return;
-				const remote = createRemoteInfo(matchArgs.remoteInfo || matchArgs.remote);
-				const hostRemotes = getHostRemotesSummary(matchArgs.options);
-				recordEvent({
-					phase: "matchRemote",
-					status: matchArgs.error ? "error" : "success",
-					requestId: matchArgs.id,
-					lifecycle: "afterMatchRemote",
-					expose: matchArgs.expose,
-					remote,
-					message: matchArgs.error ? "remote:match-failed" : "remote:matched",
-					error: matchArgs.error,
-					errorContext: hostRemotes ? { hostRemotes } : void 0
-				}, matchArgs.origin);
-			},
-			beforeLoadRemoteSnapshot(args) {
-				const snapshotArgs = args;
-				if (!prepareRuntimeOrigin(snapshotArgs.origin)) return;
-				const remote = createRemoteInfo(snapshotArgs.moduleInfo);
-				if (!isManifestUrl(remote?.entry)) return;
-				recordEvent({
-					phase: "manifest",
-					status: "start",
-					requestId: remote?.entry,
-					remote,
-					url: remote?.entry,
-					lifecycle: "beforeLoadRemoteSnapshot",
-					message: "manifest:load-start"
-				}, snapshotArgs.origin);
-			},
-			loadRemoteSnapshot(args) {
-				if (options.enabled === false) return;
-			},
-			afterResolve(args) {
-				const resolveArgs = args;
-				if (!prepareRuntimeOrigin(resolveArgs.origin)) return;
-				const remote = createRemoteInfo(resolveArgs.remoteInfo || resolveArgs.remote);
-				if (!isManifestUrl(remote?.entry)) return;
-				const manifestUrl = sanitizeUrl(remote?.entry);
-				const cached = resolveArgs.cached === true || Boolean(manifestUrl && seenManifestUrls.has(manifestUrl));
-				recordEvent({
-					phase: "manifest",
-					status: "success",
-					requestId: remote?.entry,
-					expose: resolveArgs.expose,
-					remote,
-					url: remote?.entry,
-					lifecycle: "afterResolve",
-					message: "manifest:resolved",
-					cached
-				}, resolveArgs.origin);
-				if (manifestUrl) seenManifestUrls.add(manifestUrl);
-			},
-			onLoad(args) {
-				const loadArgs = args;
-				if (!prepareRuntimeOrigin(loadArgs.origin)) return;
-				recordEvent({
-					phase: "loadRemote",
-					status: "success",
-					requestId: loadArgs.id,
-					lifecycle: "onLoad",
-					expose: loadArgs.expose,
-					remote: createRemoteInfo(loadArgs.remote),
-					message: "remote:loaded"
-				}, loadArgs.origin);
-			},
-			errorLoadRemote(args) {
-				const errorArgs = args;
-				if (!prepareRuntimeOrigin(errorArgs.origin) || errorArgs.lifecycle !== "onLoad" && errorArgs.lifecycle !== "beforeRequest" && errorArgs.lifecycle !== "afterResolve") return;
-				const isManifestError = errorArgs.lifecycle === "afterResolve";
-				recordEvent({
-					phase: isManifestError ? "manifest" : "loadRemote",
-					status: "error",
-					requestId: errorArgs.id,
-					lifecycle: errorArgs.lifecycle,
-					expose: errorArgs.expose,
-					remote: createRemoteInfo(errorArgs.remote),
-					url: isManifestError ? errorArgs.id : void 0,
-					message: isManifestError ? "manifest:failed" : errorArgs.lifecycle ? `remote:${errorArgs.lifecycle}:failed` : "remote:failed",
-					error: errorArgs.error
-				}, errorArgs.origin);
-			},
-			afterLoadRemote(args) {
-				const loadArgs = args;
-				if (!prepareRuntimeOrigin(loadArgs.origin)) return;
-				recordEvent({
-					phase: "loadRemote",
-					status: "complete",
-					requestId: loadArgs.id,
-					lifecycle: "afterLoadRemote",
-					expose: loadArgs.expose,
-					remote: createRemoteInfo(loadArgs.remote),
-					message: loadArgs.recovered ? "remote:load-recovered" : loadArgs.error ? "remote:load-failed" : "remote:load-complete",
-					error: loadArgs.error,
-					recovered: loadArgs.recovered
-				}, loadArgs.origin);
-			},
-			loadEntry(args) {
-				const entryArgs = args;
-				if (!prepareRuntimeOrigin(entryArgs.origin)) return;
-				const remote = createRemoteInfo(entryArgs.remoteInfo);
-				recordEvent({
-					phase: "remoteEntry",
-					status: "start",
-					requestId: remote?.name,
-					remote,
-					url: remote?.entry,
-					lifecycle: "loadEntry",
-					message: "remoteEntry:load-start"
-				}, entryArgs.origin);
-			},
-			afterLoadEntry(args) {
-				const entryArgs = args;
-				if (!prepareRuntimeOrigin(entryArgs.origin)) return;
-				const remote = createRemoteInfo(entryArgs.remoteInfo);
-				const remoteEntryKey = getRemoteEntryKey(sanitizeRemote(remote));
-				const cached = entryArgs.cached === true || Boolean(remoteEntryKey && seenRemoteEntryKeys.has(remoteEntryKey));
-				recordEvent({
-					phase: "remoteEntry",
-					status: entryArgs.error ? "error" : "success",
-					requestId: remote?.name,
-					remote,
-					url: remote?.entry,
-					lifecycle: "afterLoadEntry",
-					message: entryArgs.error ? "remoteEntry:load-failed" : entryArgs.recovered ? "remoteEntry:load-recovered" : "remoteEntry:loaded",
-					error: entryArgs.error,
-					recovered: entryArgs.recovered,
-					cached
-				}, entryArgs.origin);
-				if (!entryArgs.error && remoteEntryKey) seenRemoteEntryKeys.add(remoteEntryKey);
-			},
-			beforeInitRemote(args) {
-				const initArgs = args;
-				if (!prepareRuntimeOrigin(initArgs.origin)) return;
-				const remote = createRemoteInfo(initArgs.remoteInfo);
-				recordEvent({
-					phase: "remoteEntryInit",
-					status: "start",
-					requestId: initArgs.id || remote?.name,
-					remote,
-					lifecycle: "beforeInitRemote",
-					message: "remoteEntry:init-start"
-				}, initArgs.origin);
-			},
-			afterInitRemote(args) {
-				const initArgs = args;
-				if (!prepareRuntimeOrigin(initArgs.origin)) return;
-				const remote = createRemoteInfo(initArgs.remoteInfo);
-				recordEvent({
-					phase: "remoteEntryInit",
-					status: initArgs.error ? "error" : "success",
-					requestId: initArgs.id || remote?.name,
-					remote,
-					lifecycle: "afterInitRemote",
-					message: initArgs.error ? "remoteEntry:init-failed" : initArgs.cached ? "remoteEntry:init-reused" : "remoteEntry:initialized",
-					error: initArgs.error,
-					cached: initArgs.cached
-				}, initArgs.origin);
-			},
-			beforeGetExpose(args) {
-				const exposeArgs = args;
-				if (!prepareRuntimeOrigin(exposeArgs.origin)) return;
-				recordEvent({
-					phase: "expose",
-					status: "start",
-					requestId: exposeArgs.id,
-					expose: exposeArgs.expose,
-					remote: createRemoteInfo(exposeArgs.moduleInfo),
-					lifecycle: "beforeGetExpose",
-					message: "expose:get-start"
-				}, exposeArgs.origin);
-			},
-			afterGetExpose(args) {
-				const exposeArgs = args;
-				if (!prepareRuntimeOrigin(exposeArgs.origin)) return;
-				recordEvent({
-					phase: "expose",
-					status: exposeArgs.error ? "error" : "success",
-					requestId: exposeArgs.id,
-					expose: exposeArgs.expose,
-					remote: createRemoteInfo(exposeArgs.moduleInfo),
-					lifecycle: "afterGetExpose",
-					message: exposeArgs.error ? "expose:get-failed" : "expose:resolved",
-					error: exposeArgs.error
-				}, exposeArgs.origin);
-			},
-			beforeExecuteFactory(args) {
-				const factoryArgs = args;
-				if (!prepareRuntimeOrigin(factoryArgs.origin)) return;
-				recordEvent({
-					phase: "moduleFactory",
-					status: "start",
-					requestId: factoryArgs.id,
-					expose: factoryArgs.expose,
-					remote: createRemoteInfo(factoryArgs.moduleInfo),
-					lifecycle: "beforeExecuteFactory",
-					message: "moduleFactory:execute-start"
-				}, factoryArgs.origin);
-			},
-			afterExecuteFactory(args) {
-				const factoryArgs = args;
-				if (!prepareRuntimeOrigin(factoryArgs.origin)) return;
-				recordEvent({
-					phase: "moduleFactory",
-					status: factoryArgs.error ? "error" : "success",
-					requestId: factoryArgs.id,
-					expose: factoryArgs.expose,
-					remote: createRemoteInfo(factoryArgs.moduleInfo),
-					lifecycle: "afterExecuteFactory",
-					message: factoryArgs.error ? "moduleFactory:execute-failed" : "moduleFactory:executed",
-					error: factoryArgs.error
-				}, factoryArgs.origin);
-			},
-			beforeLoadShare(args) {
-				if (!prepareRuntimeOrigin(args.origin)) return args;
-				recordEvent({
-					phase: "shared",
-					status: "start",
-					requestId: `shared:${args.pkgName}`,
-					lifecycle: "loadShare",
-					shared: createSharedInfo(args),
-					message: "shared:load-start"
-				}, args.origin);
-				return args;
-			},
-			afterLoadShare(args) {
-				if (!prepareRuntimeOrigin(args.origin)) return;
-				recordEvent({
-					phase: "shared",
-					status: "success",
-					requestId: `shared:${args.pkgName}`,
-					lifecycle: args.lifecycle,
-					shared: createSharedInfo(args),
-					message: args.lifecycle === "loadShareSync" ? "shared:resolved-sync" : "shared:resolved"
-				}, args.origin);
-			},
-			errorLoadShare(args) {
-				if (!prepareRuntimeOrigin(args.origin)) return;
-				const reason = getSharedErrorReason(args);
-				recordEvent({
-					phase: "shared",
-					status: "error",
-					requestId: `shared:${args.pkgName}`,
-					lifecycle: args.lifecycle,
-					shared: createSharedInfo(args, reason),
-					message: reason ? `shared:${reason}` : void 0,
-					error: args.error,
-					recovered: args.recovered
-				}, args.origin);
-			}
-		},
-		getEvents() {
-			return getEventsSnapshot();
-		},
-		getTraceIds() {
-			return getTraceIdsSnapshot();
-		},
-		getReports(options) {
-			return getReportsSnapshot(options);
-		},
-		findReports(query) {
-			return findReportsSnapshot(query);
-		},
-		getLatestReport() {
-			return getLatestReportSnapshot();
-		},
-		getReport(traceId) {
-			return getReportSnapshot(traceId);
-		},
-		exportReport(traceId) {
-			return exportReportSnapshot(traceId);
-		},
-		clear() {
-			events.length = 0;
-			reports.clear();
-			traceByRequest.clear();
-			traceByRemote.clear();
-			phaseStartTimes.clear();
-			seenManifestUrls.clear();
-			seenRemoteEntryKeys.clear();
-			consoleReportedTraceIds.clear();
-			latestTraceId = void 0;
-			runtimeObservabilityEnabled = false;
-			effectiveMaxEvents = configuredMaxEvents;
-			browserGlobalScope = void 0;
-			lastRuntimeOrigin = void 0;
-		},
-		markComponentLoaded(markOptions = {}) {
-			if (options.enabled === false || !runtimeObservabilityEnabled) return;
-			return recordEvent({
-				traceId: markOptions.traceId || (markOptions.requestId ? traceByRequest.get(sanitizeRequestId(markOptions.requestId) || "") : void 0) || latestTraceId || createTraceId({
-					phase: "component",
-					status: "success",
-					requestId: markOptions.requestId
-				}),
-				phase: "component",
-				status: "success",
-				requestId: markOptions.requestId,
-				componentName: markOptions.componentName,
-				metadata: markOptions.metadata,
-				eventName: COMPONENT_BUSINESS_LOADED_EVENT,
-				message: COMPONENT_BUSINESS_LOADED_EVENT,
-				source: "business"
-			}, lastRuntimeOrigin);
-		}
-	};
-}
-
-//#endregion
-exports.ObservabilityPlugin = ObservabilityPlugin;
+exports.ChromeObservabilityPlugin = require_chrome_devtool.ChromeObservabilityPlugin;
+exports.ObservabilityPlugin = require_browser.ObservabilityPlugin;
+exports.createObservability = require_core.createObservability;
+exports.default = require_browser.ObservabilityPlugin;