@od-oneapp/analytics 2026.2.1701 → 2026.2.2001-canary.1

package/client-next.mjs

@@ -1,12 +1,15 @@
 'use client';
 
-import { a as ContextBuilder, c as createAnonymousSession, d as isGroupPayload, f as isIdentifyPayload, g as withUTM, h as withMetadata, i as getDistinctIdFromCookies, l as createUserSession, m as isTrackPayload, n as createMinimalBootstrapData, o as EventBatch, p as isPagePayload, r as generateDistinctId, s as PayloadBuilder, t as createBootstrapData, u as isAliasPayload, v as createAnalyticsManager } from "./posthog-bootstrap-CYfIy_WS.mjs";
-import { a as screen, i as page, n as group, o as track, r as identify, t as alias } from "./emitters-6-nKo8i-.mjs";
-import { t as ecommerce_exports } from "./ecommerce-Cgu4wlux.mjs";
-import { a as createEmitterProcessor, i as validateConfig, n as createConfigBuilder, o as processEmitterPayload, r as getAnalyticsConfig, s as trackEcommerceEvent, t as PROVIDER_REQUIREMENTS } from "./config-P6P5adJg.mjs";
+import { i as logWarn, n as logError, t as logDebug } from "./core-C3oFD9Vr.mjs";
+import { i as logWarn$1, n as logError$1 } from "./logs-8LsA--uG.mjs";
+import { a as ContextBuilder, c as createAnonymousSession, d as isGroupPayload, f as isIdentifyPayload, g as withUTM, h as withMetadata, i as getDistinctIdFromCookies, l as createUserSession, m as isTrackPayload, n as createMinimalBootstrapData, o as EventBatch, p as isPagePayload, r as generateDistinctId, s as PayloadBuilder, t as createBootstrapData, u as isAliasPayload, v as createAnalyticsManager } from "./posthog-bootstrap-DkDBbvMJ.mjs";
+import { a as screen, i as page, n as group, o as track, r as identify, t as alias } from "./emitters-RheHbeX2.mjs";
+import { t as ecommerce_exports } from "./ecommerce-DAo98u3I.mjs";
+import { a as createEmitterProcessor, i as validateConfig, n as createConfigBuilder, o as processEmitterPayload, r as getAnalyticsConfig, s as trackEcommerceEvent, t as PROVIDER_REQUIREMENTS } from "./config-DKN8G0TI.mjs";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useParams, usePathname, useRouter, useSearchParams } from "next/navigation";
-import { createClientObservability } from "@od-oneapp/observability/client/next";
+import { createEnv } from "@t3-oss/env-core";
+import { z } from "zod/v4";
 import { jsx } from "react/jsx-runtime";
 
 //#region src/client/next/manager.ts
@@ -25,7 +28,6 @@ import { jsx } from "react/jsx-runtime";
 *
 * @module @od-oneapp/analytics/client/next/manager
 */
-const logWarn = (_message, _context) => {};
 /**
 * Create a Next.js client analytics instance with runtime provider loading
 * Only imports providers that are actually configured to avoid webpack bundling unused dependencies
@@ -45,7 +47,7 @@ async function createNextJSClientAnalytics(config) {
 			case "console": {
 				const module = await import(
 					/* webpackChunkName: "analytics-console" */
-					"./client-CTzJVFU5.mjs"
+					"./client-uX7stpb0.mjs"
 ).then((n) => n.t);
 				CLIENT_PROVIDERS.console = (config) => new module.ConsoleProvider(config);
 				break;
@@ -53,7 +55,7 @@ async function createNextJSClientAnalytics(config) {
 			case "posthog": {
 				const module = await import(
 					/* webpackChunkName: "analytics-posthog" */
-					"./client-CeOLjbac.mjs"
+					"./client-ClA-Qeks.mjs"
 );
 				CLIENT_PROVIDERS.posthog = (config) => new module.PostHogClientProvider(config);
 				break;
@@ -61,15 +63,23 @@ async function createNextJSClientAnalytics(config) {
 			case "segment": {
 				const module = await import(
 					/* webpackChunkName: "analytics-segment" */
-					"./client-D339NFJS.mjs"
+					"./client-B0v807xN.mjs"
 );
 				CLIENT_PROVIDERS.segment = (config) => new module.SegmentClientProvider(config);
 				break;
 			}
+			case "http": {
+				const module = await import(
+					/* webpackChunkName: "analytics-http" */
+					"./providers-http-client.mjs"
+);
+				CLIENT_PROVIDERS.http = (config) => new module.HttpClientProvider(config);
+				break;
+			}
 			case "vercel": {
 				const module = await import(
 					/* webpackChunkName: "analytics-vercel" */
-					"./client-CcFTauAh.mjs"
+					"./client-BrLI6DF9.mjs"
 );
 				CLIENT_PROVIDERS.vercel = (config) => new module.VercelClientProvider(config);
 				break;
@@ -99,22 +109,27 @@ async function createNextJSClientAnalyticsUninitialized(config) {
 	const configuredProviders = Object.keys(config.providers);
 	for (const providerName of configuredProviders) switch (providerName) {
 		case "console": {
-			const { ConsoleProvider } = await import("./client-CTzJVFU5.mjs").then((n) => n.t);
+			const { ConsoleProvider } = await import("./client-uX7stpb0.mjs").then((n) => n.t);
 			CLIENT_PROVIDERS.console = (config) => new ConsoleProvider(config);
 			break;
 		}
 		case "posthog": {
-			const { PostHogClientProvider } = await import("./client-CeOLjbac.mjs");
+			const { PostHogClientProvider } = await import("./client-ClA-Qeks.mjs");
 			CLIENT_PROVIDERS.posthog = (config) => new PostHogClientProvider(config);
 			break;
 		}
 		case "segment": {
-			const { SegmentClientProvider } = await import("./client-D339NFJS.mjs");
+			const { SegmentClientProvider } = await import("./client-B0v807xN.mjs");
 			CLIENT_PROVIDERS.segment = (config) => new SegmentClientProvider(config);
 			break;
 		}
+		case "http": {
+			const { HttpClientProvider } = await import("./providers-http-client.mjs");
+			CLIENT_PROVIDERS.http = (config) => new HttpClientProvider(config);
+			break;
+		}
 		case "vercel": {
-			const { VercelClientProvider } = await import("./client-CcFTauAh.mjs");
+			const { VercelClientProvider } = await import("./client-BrLI6DF9.mjs");
 			CLIENT_PROVIDERS.vercel = (config) => new VercelClientProvider(config);
 			break;
 		}
@@ -125,6 +140,16 @@ async function createNextJSClientAnalyticsUninitialized(config) {
 	return createAnalyticsManager(config, CLIENT_PROVIDERS);
 }
 
+//#endregion
+//#region src/client/next/state.ts
+let globalAnalytics = null;
+function getGlobalAnalytics() {
+	return globalAnalytics;
+}
+function setGlobalAnalytics(analytics) {
+	globalAnalytics = analytics;
+}
+
 //#endregion
 //#region src/client/next/hooks.ts
 /**
@@ -146,7 +171,6 @@ async function createNextJSClientAnalyticsUninitialized(config) {
 *
 * @module @od-oneapp/analytics/client/next/hooks
 */
-let globalAnalytics$1 = null;
 /**
 * Hook to get or create analytics instance.
 *
@@ -170,19 +194,25 @@ let globalAnalytics$1 = null;
 function useAnalytics(config) {
 	const [analytics, setAnalytics] = useState(null);
 	useEffect(() => {
-		if (!globalAnalytics$1 && config) {
+		const currentAnalytics = getGlobalAnalytics();
+		if (!currentAnalytics && config) {
 			const initAnalytics = async () => {
 				try {
 					const instance = await createNextJSClientAnalytics(config);
-					globalAnalytics$1 = instance;
+					setGlobalAnalytics(instance);
 					setAnalytics(instance);
-				} catch {}
+				} catch (error) {
+					logError("Failed to initialize Next.js analytics client", {
+						error: error instanceof Error ? error.message : String(error),
+						configProviders: Object.keys(config.providers)
+					});
+				}
 			};
 			initAnalytics();
-		} else if (globalAnalytics$1 && analytics !== globalAnalytics$1) setTimeout(() => {
-			setAnalytics(globalAnalytics$1);
+		} else if (currentAnalytics && analytics !== currentAnalytics) setTimeout(() => {
+			setAnalytics(currentAnalytics);
 		}, 0);
-	}, [config]);
+	}, [analytics, config]);
 	return analytics;
 }
 /**
@@ -209,7 +239,8 @@ function usePageTracking(options) {
 	const params = useParams();
 	const tracked = useRef("");
 	useEffect(() => {
-		if (options?.skip || !globalAnalytics$1) return;
+		const analyticsInstance = getGlobalAnalytics();
+		if (options?.skip || !analyticsInstance) return;
 		const searchString = options?.trackSearch ? searchParams.toString() : "";
 		const pageKey = `${pathname}${searchString}`;
 		if (tracked.current === pageKey) return;
@@ -226,7 +257,7 @@ function usePageTracking(options) {
 			properties.search_params = Object.fromEntries(searchParams.entries());
 		}
 		if (options?.trackParams && params) properties.route_params = params;
-		globalAnalytics$1.page(pathname, properties);
+		analyticsInstance.page(pathname, properties);
 	}, [
 		pathname,
 		searchParams,
@@ -254,8 +285,9 @@ function usePageTracking(options) {
 */
 function useTrackEvent() {
 	return useCallback((event, properties, options) => {
-		if (!globalAnalytics$1) return;
-		globalAnalytics$1.track(event, properties, options);
+		const analyticsInstance = getGlobalAnalytics();
+		if (!analyticsInstance) return;
+		analyticsInstance.track(event, properties, options);
 	}, []);
 }
 /**
@@ -275,8 +307,9 @@ function useTrackEvent() {
 */
 function useIdentifyUser() {
 	return useCallback((userId, traits, options) => {
-		if (!globalAnalytics$1) return;
-		globalAnalytics$1.identify(userId, traits, options);
+		const analyticsInstance = getGlobalAnalytics();
+		if (!analyticsInstance) return;
+		analyticsInstance.identify(userId, traits, options);
 	}, []);
 }
 /**
@@ -294,7 +327,1560 @@ function useIdentifyUser() {
 * ```
 */
 function resetAnalytics() {
-	globalAnalytics$1 = null;
+	setGlobalAnalytics(null);
+}
+
+//#endregion
+//#region ../observability/env.ts
+/**
+* @fileoverview Core environment configuration for the observability package
+* Core environment configuration for the observability package
+* Provider-specific configurations are handled by their respective plugins
+*/
+const env$2 = createEnv({
+	server: {},
+	clientPrefix: "NEXT_PUBLIC_",
+	client: {
+		NEXT_PUBLIC_NODE_ENV: z.enum([
+			"development",
+			"test",
+			"production"
+		]).default("development"),
+		NEXT_PUBLIC_OBSERVABILITY_DEBUG: z.string().optional().transform((val) => val === "true").default(false),
+		NEXT_PUBLIC_OBSERVABILITY_CONSOLE_ENABLED: z.string().optional().transform((val) => val === "true" ? true : val === "false" ? false : void 0)
+	},
+	runtimeEnv: process.env,
+	emptyStringAsUndefined: true,
+	onInvalidAccess: (variable) => {
+		throw new Error(`❌ Attempted to access a server-side environment variable on the client: ${variable}`);
+	},
+	onValidationError: (error) => {
+		logWarn("Observability package environment validation failed", { error });
+	}
+});
+
+//#endregion
+//#region ../observability/src/core/manager.ts
+/**
+* @fileoverview ObservabilityManager - Core orchestrator for multiple observability providers
+* ObservabilityManager - Core orchestrator for multiple observability providers
+*/
+/**
+* Manager that orchestrates multiple observability plugins
+* Broadcasts all method calls to enabled plugins
+*/
+var ObservabilityManager = class {
+	plugins = /* @__PURE__ */ new Map();
+	initialized = false;
+	initializationPromise = null;
+	lifecycle = {};
+	initializationError = null;
+	/**
+	* Create a new ObservabilityManager instance.
+	*
+	* @param lifecycle - Optional lifecycle callbacks for plugin events
+	*/
+	constructor(lifecycle) {
+		if (lifecycle) this.lifecycle = lifecycle;
+	}
+	/**
+	* Add a plugin to the manager
+	*/
+	addPlugin(plugin) {
+		this.plugins.set(plugin.name, plugin);
+		return this;
+	}
+	/**
+	* Get a specific plugin by name.
+	*
+	* @param name - Name of the plugin to retrieve
+	* @returns Plugin instance if found, undefined otherwise
+	*/
+	getPlugin(name) {
+		return this.plugins.get(name);
+	}
+	/**
+	* Get all registered plugins.
+	*
+	* @returns Array of all registered plugins
+	*/
+	getPlugins() {
+		return Array.from(this.plugins.values());
+	}
+	/**
+	* List all registered plugins (alias for getPlugins).
+	*
+	* @returns Array of all registered plugins
+	*/
+	listPlugins() {
+		return this.getPlugins();
+	}
+	/**
+	* Initialize all plugins
+	* Note: Failed initialization is retryable - subsequent calls will re-attempt initialization.
+	* This allows recovery from transient failures (network issues, temporary misconfigurations).
+	*/
+	async initialize() {
+		if (this.initializationPromise) return this.initializationPromise;
+		if (this.initialized) return;
+		if (this.initializationError) {
+			logWarn$1("ObservabilityManager: Retrying failed initialization");
+			this.initializationError = null;
+		}
+		this.initializationPromise = this.doInitialize();
+		try {
+			await this.initializationPromise;
+		} finally {
+			this.initializationPromise = null;
+		}
+	}
+	async doInitialize() {
+		const initPromises = Array.from(this.plugins.values()).filter((plugin) => plugin.enabled && plugin.initialize).map(async (plugin) => {
+			try {
+				if (plugin.initialize) await plugin.initialize();
+				this.lifecycle.onInitialized?.(plugin);
+			} catch (error) {
+				logError$1(`Failed to initialize plugin ${plugin.name}`, {
+					error,
+					pluginName: plugin.name
+				});
+				this.lifecycle.onError?.(error, plugin);
+				throw error;
+			}
+		});
+		try {
+			await Promise.all(initPromises);
+			this.initialized = true;
+		} catch (error) {
+			this.initializationError = error instanceof Error ? error : new Error(String(error));
+			throw this.initializationError;
+		}
+	}
+	/**
+	* Check if initialization had an error
+	* @returns `true` if initialization failed, `false` otherwise
+	*/
+	hasInitializationError() {
+		return this.initializationError !== null;
+	}
+	/**
+	* Get the initialization error if one occurred
+	* @returns The initialization error or `null` if no error
+	*/
+	getInitializationError() {
+		return this.initializationError;
+	}
+	/**
+	* Shutdown all plugins
+	*/
+	async shutdown() {
+		const shutdownPromises = Array.from(this.plugins.values()).filter((plugin) => plugin.shutdown).map(async (plugin) => {
+			try {
+				if (plugin.shutdown) await plugin.shutdown();
+				this.lifecycle.onShutdown?.(plugin);
+			} catch (error) {
+				logError$1(`Failed to shutdown plugin ${plugin.name}`, {
+					error,
+					pluginName: plugin.name
+				});
+				this.lifecycle.onError?.(error, plugin);
+			}
+		});
+		await Promise.allSettled(shutdownPromises);
+		this.initialized = false;
+	}
+	/**
+	* Broadcast exception to all enabled plugins.
+	*
+	* @param error - Error object or unknown error value
+	* @param context - Optional additional context data
+	*/
+	captureException(error, context) {
+		this.broadcast((plugin) => plugin.captureException(error, context));
+	}
+	/**
+	* Broadcast message to all enabled plugins.
+	*
+	* @param message - Message to log
+	* @param level - Log level (default: 'info')
+	* @param context - Optional additional context data
+	*/
+	captureMessage(message, level = "info", context) {
+		this.broadcast((plugin) => plugin.captureMessage(message, level, context));
+	}
+	/**
+	* Validate and sanitize user data to prevent injection and DoS attacks
+	* @param user - User data to validate
+	* @returns Validated user data with length limits and format validation applied
+	*/
+	validateUser(user) {
+		if (!user) return null;
+		const id = String(user.id).trim().slice(0, 255);
+		if (!id) {
+			logWarn$1("ObservabilityManager: User ID is empty, ignoring user data");
+			return null;
+		}
+		const validated = { id };
+		if ("email" in user && user.email) {
+			const email = String(user.email).trim().slice(0, 255);
+			if (email && /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test(email)) validated.email = email;
+		}
+		if ("username" in user && user.username) {
+			const username = String(user.username).trim().slice(0, 255);
+			if (username) validated.username = username;
+		}
+		if ("ip_address" in user && user.ip_address) {
+			const ip = String(user.ip_address).trim();
+			const isValidIPv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(ip);
+			const looksLikeIPv6 = /^[0-9a-fA-F:]+$/.test(ip) && ip.includes(":") && ip.split(":").length <= 8;
+			if (isValidIPv4 || looksLikeIPv6) validated.ip_address = ip.slice(0, 45);
+		}
+		return validated;
+	}
+	/**
+	* Set user on all enabled plugins
+	* User data is validated and sanitized before being set
+	* @param user - User data to set (will be validated)
+	*/
+	setUser(user) {
+		const validatedUser = this.validateUser(user);
+		this.broadcast((plugin) => plugin.setUser(validatedUser));
+	}
+	/**
+	* Add breadcrumb to all enabled plugins.
+	*
+	* @param breadcrumb - Breadcrumb data to add
+	*/
+	addBreadcrumb(breadcrumb) {
+		this.broadcast((plugin) => plugin.addBreadcrumb(breadcrumb));
+	}
+	/**
+	* Execute callback within scope for all enabled plugins.
+	*
+	* @param callback - Callback that receives the scope
+	*/
+	withScope(callback) {
+		this.broadcast((plugin) => plugin.withScope(callback));
+	}
+	/**
+	* Flush all plugins that support it.
+	*
+	* Waits for all enabled plugins with flush capability to send pending events.
+	*
+	* @param timeout - Maximum time to wait in milliseconds
+	* @returns Promise resolving to true if all plugins flushed successfully
+	*/
+	async flush(timeout) {
+		const flushPromises = Array.from(this.plugins.values()).filter((plugin) => {
+			return plugin.enabled && "flush" in plugin && typeof plugin.flush === "function";
+		}).map((plugin) => plugin.flush(timeout));
+		if (flushPromises.length === 0) return true;
+		return (await Promise.allSettled(flushPromises)).every((result) => result.status === "fulfilled" && result.value === true);
+	}
+	/**
+	* Helper to broadcast a method call to all enabled plugins
+	* Uses nested try-catch to ensure errors in error handling don't prevent other plugins from executing
+	*/
+	broadcast(fn) {
+		this.plugins.forEach((plugin) => {
+			if (plugin.enabled) try {
+				fn(plugin);
+			} catch (error) {
+				try {
+					logError$1(`Plugin ${plugin.name} error`, {
+						error,
+						pluginName: plugin.name
+					});
+				} catch {}
+				try {
+					this.lifecycle.onError?.(error, plugin);
+				} catch {}
+			}
+		});
+	}
+	/**
+	* Check if manager has any enabled plugins.
+	*
+	* @returns True if at least one plugin is enabled, false otherwise
+	*/
+	hasEnabledPlugins() {
+		return Array.from(this.plugins.values()).some((plugin) => plugin.enabled);
+	}
+	/**
+	* Get names of all enabled plugins.
+	*
+	* @returns Array of plugin names that are currently enabled
+	*/
+	getEnabledPluginNames() {
+		return Array.from(this.plugins.values()).filter((plugin) => plugin.enabled).map((plugin) => plugin.name);
+	}
+};
+
+//#endregion
+//#region ../observability/src/factory/builder.ts
+/**
+* @fileoverview ObservabilityBuilder - Fluent API for building observability instances
+* ObservabilityBuilder - Fluent API for building observability instances
+*/
+/**
+* Builder for creating configured ObservabilityManager instances
+*/
+var ObservabilityBuilder = class ObservabilityBuilder {
+	plugins = [];
+	lifecycle = {};
+	autoInitialize = true;
+	/**
+	* Add a plugin to the observability stack
+	* @param plugin - Observability plugin to add
+	* @returns Builder instance for chaining
+	*/
+	withPlugin(plugin) {
+		if (plugin) this.plugins.push(plugin);
+		return this;
+	}
+	/**
+	* Add multiple plugins at once
+	* @param plugins - Array of observability plugins to add
+	* @returns Builder instance for chaining
+	*/
+	withPlugins(plugins) {
+		if (plugins && Array.isArray(plugins)) {
+			const validPlugins = plugins.filter((plugin) => plugin != null);
+			this.plugins.push(...validPlugins);
+		}
+		return this;
+	}
+	/**
+	* Set lifecycle callbacks for plugin management
+	* @param lifecycle - Lifecycle callback configuration
+	* @returns Builder instance for chaining
+	*/
+	withLifecycle(lifecycle) {
+		this.lifecycle = {
+			...this.lifecycle,
+			...lifecycle
+		};
+		return this;
+	}
+	/**
+	* Configure whether to auto-initialize plugins (default: true)
+	*/
+	withAutoInitialize(autoInitialize) {
+		this.autoInitialize = autoInitialize;
+		return this;
+	}
+	/**
+	* Build the ObservabilityManager instance
+	* @returns Configured ObservabilityManager instance
+	*/
+	build() {
+		const manager = new ObservabilityManager(this.lifecycle);
+		this.plugins.forEach((plugin) => manager.addPlugin(plugin));
+		if (this.autoInitialize && typeof process !== "undefined" && process.env.NEXT_RUNTIME !== "edge") (async () => {
+			try {
+				await manager.initialize();
+			} catch (error) {
+				try {
+					logError$1("Failed to initialize observability", { error });
+				} catch {}
+			}
+		})();
+		return manager;
+	}
+	/**
+	* Build and initialize the ObservabilityManager instance
+	* @returns Promise resolving to initialized ObservabilityManager
+	*/
+	async buildWithAutoInit() {
+		const manager = new ObservabilityManager(this.lifecycle);
+		this.plugins.forEach((plugin) => manager.addPlugin(plugin));
+		try {
+			await manager.initialize();
+		} catch {}
+		return manager;
+	}
+	/**
+	* Create a new builder instance
+	* @returns New ObservabilityBuilder instance
+	*/
+	static create() {
+		return new ObservabilityBuilder();
+	}
+};
+
+//#endregion
+//#region ../observability/src/plugins/betterstack/env.ts
+/**
+* @fileoverview Better Stack (Logtail) environment configuration
+* Better Stack (Logtail) environment configuration
+* Updated to support official @logtail packages
+*/
+const env$1 = createEnv({
+	server: {
+		LOGTAIL_SOURCE_TOKEN: z.string().optional(),
+		BETTERSTACK_SOURCE_TOKEN: z.string().optional(),
+		BETTER_STACK_SOURCE_TOKEN: z.string().optional(),
+		BETTER_STACK_INGESTING_URL: z.string().url().optional(),
+		BETTER_STACK_LOG_LEVEL: z.enum([
+			"debug",
+			"info",
+			"warn",
+			"error",
+			"off"
+		]).optional()
+	},
+	client: {
+		NEXT_PUBLIC_LOGTAIL_TOKEN: z.string().optional(),
+		NEXT_PUBLIC_BETTERSTACK_TOKEN: z.string().optional(),
+		NEXT_PUBLIC_BETTER_STACK_SOURCE_TOKEN: z.string().optional(),
+		NEXT_PUBLIC_BETTER_STACK_INGESTING_URL: z.string().url().optional(),
+		NEXT_PUBLIC_BETTER_STACK_LOG_LEVEL: z.enum([
+			"debug",
+			"info",
+			"warn",
+			"error",
+			"off"
+		]).optional()
+	},
+	clientPrefix: "NEXT_PUBLIC_",
+	runtimeEnv: process.env,
+	emptyStringAsUndefined: true,
+	onInvalidAccess: (variable) => {
+		throw new Error(`❌ Attempted to access a server-side environment variable on the client: ${variable}`);
+	},
+	onValidationError: (error) => {
+		logWarn("Better Stack environment validation failed", { error });
+	}
+});
+/**
+* Safe environment access for non-Next.js contexts.
+*
+* Provides fallback environment variable access for Node.js, workers, and test environments
+* where the validated env object may not be available. Returns fallback values with proper
+* priority handling for legacy and official Better Stack variable names.
+*
+* @returns Environment object with Better Stack configuration values
+*/
+function safeEnv$1() {
+	if (env$1) return env$1;
+	return {
+		LOGTAIL_SOURCE_TOKEN: process.env.LOGTAIL_SOURCE_TOKEN ?? process.env.BETTERSTACK_SOURCE_TOKEN ?? "",
+		BETTERSTACK_SOURCE_TOKEN: process.env.BETTERSTACK_SOURCE_TOKEN ?? process.env.LOGTAIL_SOURCE_TOKEN ?? "",
+		NEXT_PUBLIC_LOGTAIL_TOKEN: process.env.NEXT_PUBLIC_LOGTAIL_TOKEN ?? process.env.NEXT_PUBLIC_BETTERSTACK_TOKEN ?? "",
+		NEXT_PUBLIC_BETTERSTACK_TOKEN: process.env.NEXT_PUBLIC_BETTERSTACK_TOKEN ?? process.env.NEXT_PUBLIC_LOGTAIL_TOKEN ?? "",
+		BETTER_STACK_SOURCE_TOKEN: process.env.BETTER_STACK_SOURCE_TOKEN ?? process.env.LOGTAIL_SOURCE_TOKEN ?? process.env.BETTERSTACK_SOURCE_TOKEN ?? "",
+		BETTER_STACK_INGESTING_URL: process.env.BETTER_STACK_INGESTING_URL ?? "",
+		BETTER_STACK_LOG_LEVEL: process.env.BETTER_STACK_LOG_LEVEL ?? "info",
+		NEXT_PUBLIC_BETTER_STACK_SOURCE_TOKEN: process.env.NEXT_PUBLIC_BETTER_STACK_SOURCE_TOKEN ?? process.env.NEXT_PUBLIC_LOGTAIL_TOKEN ?? process.env.NEXT_PUBLIC_BETTERSTACK_TOKEN ?? "",
+		NEXT_PUBLIC_BETTER_STACK_INGESTING_URL: process.env.NEXT_PUBLIC_BETTER_STACK_INGESTING_URL ?? "",
+		NEXT_PUBLIC_BETTER_STACK_LOG_LEVEL: process.env.NEXT_PUBLIC_BETTER_STACK_LOG_LEVEL ?? "info"
+	};
+}
+
+//#endregion
+//#region ../observability/src/plugins/betterstack/plugin.ts
+/**
+* @fileoverview Better Stack (Logtail) plugin implementation
+* Better Stack (Logtail) plugin implementation
+* Updated to use official @logtail packages
+*/
+/**
+* Maximum number of breadcrumbs to include in error/message context
+* Limits context size to prevent excessive data transmission
+*/
+const MAX_BREADCRUMBS_IN_CONTEXT = 10;
+/**
+* Maximum number of breadcrumbs to store in memory
+* Prevents unbounded memory growth while maintaining useful history
+*/
+const MAX_BREADCRUMBS_STORED = 100;
+/**
+* Better Stack plugin implementation using official @logtail packages
+*/
+/**
+* Better Stack (Logtail) plugin implementation.
+*
+* Integrates Better Stack logging service into the observability system.
+* Uses official @logtail packages (@logtail/js or @logtail/next) for unified
+* logging across environments.
+*/
+var BetterStackPlugin = class {
+	name = "betterstack";
+	enabled;
+	client;
+	initialized = false;
+	logtailPackage;
+	currentUser = null;
+	breadcrumbs = [];
+	breadcrumbIndex = 0;
+	config;
+	/**
+	* Create a new BetterStackPlugin instance.
+	*
+	* @param config - Better Stack plugin configuration
+	*/
+	constructor(config = {}) {
+		this.config = config;
+		const env = safeEnv$1();
+		const hasToken = config.sourceToken ?? env.BETTER_STACK_SOURCE_TOKEN ?? env.BETTERSTACK_SOURCE_TOKEN ?? env.LOGTAIL_SOURCE_TOKEN ?? env.NEXT_PUBLIC_BETTER_STACK_SOURCE_TOKEN ?? env.NEXT_PUBLIC_BETTERSTACK_TOKEN ?? env.NEXT_PUBLIC_LOGTAIL_TOKEN;
+		this.enabled = config.enabled ?? Boolean(hasToken);
+		this.logtailPackage = config.logtailPackage ?? this.detectLogtailPackage();
+	}
+	/**
+	* Detect which Logtail package to use based on the runtime environment.
+	*
+	* @returns Package name ('@logtail/next' for Next.js, '@logtail/js' otherwise)
+	*/
+	detectLogtailPackage() {
+		if (process.env.NEXT_RUNTIME) return "@logtail/next";
+		return "@logtail/js";
+	}
+	getClient() {
+		return this.client;
+	}
+	/**
+	* Get safe environment access (for testing/mocking).
+	*
+	* @returns Environment configuration object
+	*/
+	getSafeEnv() {
+		return safeEnv$1();
+	}
+	async initialize(config) {
+		if (this.initialized || !this.enabled) return;
+		const env = safeEnv$1();
+		const mergedConfig = {
+			...this.config,
+			...config
+		};
+		const sourceToken = mergedConfig.sourceToken ?? env.BETTER_STACK_SOURCE_TOKEN ?? env.NEXT_PUBLIC_BETTER_STACK_SOURCE_TOKEN ?? env.LOGTAIL_SOURCE_TOKEN ?? env.BETTERSTACK_SOURCE_TOKEN ?? env.NEXT_PUBLIC_LOGTAIL_TOKEN ?? env.NEXT_PUBLIC_BETTERSTACK_TOKEN;
+		if (!sourceToken) {
+			logWarn("Better Stack plugin: No source token provided, skipping initialization");
+			this.enabled = false;
+			return;
+		}
+		try {
+			const LogtailModule = await import(
+				/* webpackIgnore: true */
+				this.logtailPackage
+);
+			const LogtailClass = LogtailModule.default ?? LogtailModule.Logtail ?? LogtailModule;
+			if (!LogtailClass) {
+				logError(`Better Stack plugin: Could not find Logtail class in ${this.logtailPackage}`, { logtailPackage: this.logtailPackage });
+				this.enabled = false;
+				return;
+			}
+			const logtailConfig = { sourceToken };
+			if (mergedConfig.endpoint ?? env.BETTER_STACK_INGESTING_URL ?? env.NEXT_PUBLIC_BETTER_STACK_INGESTING_URL) logtailConfig.endpoint = mergedConfig.endpoint ?? env.BETTER_STACK_INGESTING_URL ?? env.NEXT_PUBLIC_BETTER_STACK_INGESTING_URL;
+			this.client = new LogtailClass(logtailConfig);
+			this.initialized = true;
+		} catch (error) {
+			logError(`Failed to import Logtail package '${this.logtailPackage}'`, {
+				error,
+				logtailPackage: this.logtailPackage
+			});
+			this.enabled = false;
+		}
+	}
+	async shutdown() {
+		if (this.client && this.initialized) {
+			await this.client.flush();
+			this.initialized = false;
+		}
+	}
+	captureException(error, context) {
+		if (!this.enabled || !this.client) return;
+		const errorObj = error instanceof Error ? error : new Error(String(error));
+		const data = {
+			error: {
+				name: errorObj.name,
+				message: errorObj.message,
+				stack: errorObj.stack
+			},
+			context: context?.extra,
+			tags: context?.tags,
+			user: context?.user ?? this.currentUser,
+			breadcrumbs: this.getRecentBreadcrumbs(MAX_BREADCRUMBS_IN_CONTEXT)
+		};
+		this.client.error(errorObj.message, data);
+	}
+	captureMessage(message, level = "info", context) {
+		if (!this.enabled || !this.client) return;
+		const data = {
+			level,
+			context: context?.extra,
+			tags: context?.tags,
+			user: context?.user ?? this.currentUser,
+			breadcrumbs: this.getRecentBreadcrumbs(MAX_BREADCRUMBS_IN_CONTEXT)
+		};
+		switch (level) {
+			case "debug":
+				this.client.debug(message, data);
+				break;
+			case "warning":
+				this.client.warn(message, data);
+				break;
+			case "error":
+				this.client.error(message, data);
+				break;
+			default:
+				this.client.info(message, data);
+				break;
+		}
+	}
+	setUser(user) {
+		if (!this.enabled) return;
+		this.currentUser = user;
+	}
+	addBreadcrumb(breadcrumb) {
+		if (!this.enabled) return;
+		const enriched = {
+			...breadcrumb,
+			timestamp: breadcrumb.timestamp ?? Date.now() / 1e3
+		};
+		if (this.breadcrumbs.length < MAX_BREADCRUMBS_STORED) this.breadcrumbs.push(enriched);
+		else {
+			this.breadcrumbs[this.breadcrumbIndex] = enriched;
+			this.breadcrumbIndex = (this.breadcrumbIndex + 1) % MAX_BREADCRUMBS_STORED;
+		}
+	}
+	/**
+	* Get the most recent breadcrumbs in chronological order
+	* @param count - Number of breadcrumbs to retrieve
+	* @returns Array of recent breadcrumbs
+	*/
+	getRecentBreadcrumbs(count) {
+		const { length } = this.breadcrumbs;
+		if (length === 0) return [];
+		if (length <= count) return this.breadcrumbs.slice();
+		if (length < MAX_BREADCRUMBS_STORED) return this.breadcrumbs.slice(length - count);
+		const result = [];
+		const start = (this.breadcrumbIndex - count + length) % length;
+		for (let i = 0; i < count; i++) {
+			const index = (start + i) % length;
+			const breadcrumb = this.breadcrumbs[index];
+			if (breadcrumb) result.push(breadcrumb);
+		}
+		return result;
+	}
+	withScope(callback) {
+		if (!this.enabled) return;
+		try {
+			callback({
+				setContext: (_key, _context) => {},
+				setUser: (user) => {
+					this.setUser(user);
+				}
+			});
+		} catch {}
+	}
+	async flush(_timeout) {
+		if (!this.enabled || !this.client) return true;
+		try {
+			await this.client.flush();
+			return true;
+		} catch (error) {
+			logError("Better Stack flush error", { error });
+			return false;
+		}
+	}
+};
+/**
+* Factory function to create a Better Stack plugin.
+*
+* Creates a configured BetterStackPlugin instance with optional configuration.
+* Auto-detects the appropriate @logtail package based on the environment.
+*
+* @param config - Optional Better Stack plugin configuration
+* @returns BetterStackPlugin instance
+*
+* @example
+* ```typescript
+* const betterstack = createBetterStackPlugin({
+*   sourceToken: '...',
+*   logLevel: 'info',
+* });
+* ```
+*/
+const createBetterStackPlugin = (config) => {
+	return new BetterStackPlugin(config);
+};
+
+//#endregion
+//#region ../observability/src/shared.ts
+/**
+* @fileoverview Shared observability utilities and types
+* Shared observability utilities and types
+*/
+/**
+* Get runtime environment information.
+*
+* Detects the current runtime environment (browser, Node.js, edge, Bun) and returns
+* detailed information about the environment type, version, and capabilities.
+*
+* @returns Runtime information object with type, version, and environment-specific details
+*
+* @example
+* ```typescript
+* const runtime = getRuntimeInfo();
+* // Returns: { type: 'node', version: '22.0.0', major: 22, minor: 0, isNode22Plus: true, isNextJs: true }
+* // or: { type: 'browser', isNextJs: true }
+* // or: { type: 'edge', variant: 'vercel' }
+* ```
+*/
+const getRuntimeInfo = () => {
+	if (typeof globalThis !== "undefined" && globalThis.EdgeRuntime) return {
+		type: "edge",
+		variant: "vercel"
+	};
+	if (typeof globalThis !== "undefined" && globalThis.caches && typeof globalThis.caches !== "undefined") return {
+		type: "edge",
+		variant: "cloudflare"
+	};
+	if (typeof process !== "undefined" && process.versions?.bun) return {
+		type: "bun",
+		version: process.versions.bun
+	};
+	if (typeof globalThis !== "undefined" && "window" in globalThis && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined" && typeof globalThis.window.navigator !== "undefined") return {
+		type: "browser",
+		isNextJs: Boolean(globalThis.window.__NEXT_DATA__)
+	};
+	if (typeof process !== "undefined" && process.versions?.node) {
+		const nodeVersion = parseInt(process.versions.node.split(".")[0] ?? "0");
+		const nodeVersionMinor = parseInt(process.versions.node.split(".")[1] ?? "0");
+		if (nodeVersion < 22) logWarn(`[Observability] Node ${process.versions.node} detected. Node 22+ is required for optimal performance and latest features.`);
+		return {
+			type: "node",
+			version: process.versions.node,
+			major: nodeVersion,
+			minor: nodeVersionMinor,
+			isNode22Plus: nodeVersion >= 22,
+			isNextJs: Boolean(process.env.NEXT_RUNTIME) || Boolean(process.env.__NEXT_RUNTIME) || Boolean(process.env.NEXT_PUBLIC_VERCEL_ENV)
+		};
+	}
+	return { type: "unknown" };
+};
+const runtimeInfo = getRuntimeInfo();
+/**
+* Detect if code is running in a browser environment
+* Extracted to shared utility to avoid duplication
+* @returns true if running in browser, false otherwise
+*/
+function isBrowser() {
+	return typeof globalThis !== "undefined" && "window" in globalThis && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined" && typeof globalThis.window.navigator !== "undefined";
+}
+/**
+* Determine if console logging should be enabled based on environment
+* Centralized logic to avoid duplication across entry points
+* @param envNodeEnv - The NEXT_PUBLIC_NODE_ENV value
+* @param consoleEnabled - The NEXT_PUBLIC_OBSERVABILITY_CONSOLE_ENABLED value (explicit control)
+* @param debugEnabled - The NEXT_PUBLIC_OBSERVABILITY_DEBUG value
+* @returns boolean indicating if console should be enabled
+*/
+function shouldEnableConsole(envNodeEnv, consoleEnabled, debugEnabled) {
+	const isDevelopment = envNodeEnv === "development" || true;
+	if (consoleEnabled !== void 0) return consoleEnabled;
+	if (isDevelopment) return true;
+	return debugEnabled ?? false;
+}
+
+//#endregion
+//#region ../observability/src/plugins/console/index.ts
+/**
+* @fileoverview Console plugin for observability
+* Console plugin for observability
+* Simple logging implementation for development
+*/
+/**
+* Console plugin implementation for browser environments
+*/
+/**
+* Console plugin implementation for browser environments.
+*
+* Provides simple console logging with color support for development.
+* Supports both browser (CSS colors) and Node.js (ANSI colors) environments.
+*/
+var ConsolePlugin = class {
+	name = "console";
+	enabled;
+	prefix;
+	colors;
+	isBrowser;
+	/**
+	* Create a new ConsolePlugin instance.
+	*
+	* @param config - Console plugin configuration
+	*/
+	constructor(config = {}) {
+		this.enabled = config.enabled ?? true;
+		this.prefix = config.prefix ?? "[Console]";
+		this.colors = config.colors ?? true;
+		this.isBrowser = isBrowser();
+	}
+	async initialize() {}
+	async shutdown() {}
+	getClient() {}
+	captureException(error, context) {
+		if (!this.enabled) return;
+		try {
+			const contextData = this.formatContext(context);
+			if (this.colors && this.isBrowser) console.error(`%c${this.prefix} Error:`, "color: red; font-weight: bold", error, contextData);
+			else if (this.colors) console.error(`\x1b[31m${this.prefix} Error:\x1b[0m`, error, contextData);
+			else console.error(`${this.prefix} Error:`, error, contextData);
+		} catch {}
+	}
+	captureMessage(message, level = "info", context) {
+		if (!this.enabled) return;
+		try {
+			const contextData = this.formatContext(context);
+			const logMethod = this.getLogMethod(level);
+			const levelLabel = this.getLevelLabel(level);
+			if (this.colors && this.isBrowser) {
+				const cssColor = this.getBrowserColorCSS(level);
+				console[logMethod](`%c${this.prefix} ${levelLabel}:`, cssColor, message, contextData);
+			} else if (this.colors) {
+				const ansiColor = this.getAnsiColorCode(level);
+				console[logMethod](`${ansiColor}${this.prefix} ${levelLabel}:\x1b[0m`, message, contextData);
+			} else console[logMethod](`${this.prefix} ${levelLabel}:`, message, contextData);
+		} catch {}
+	}
+	setUser(user) {
+		if (!this.enabled) return;
+		try {
+			if (user === null) console.info(this.prefix, "User cleared");
+			else console.info(this.prefix, "User set:", JSON.stringify(user));
+		} catch {}
+	}
+	addBreadcrumb(breadcrumb) {
+		if (!this.enabled) return;
+		try {
+			const enrichedBreadcrumb = {
+				...breadcrumb,
+				timestamp: breadcrumb.timestamp ?? Date.now() / 1e3
+			};
+			console.log(this.prefix, "Breadcrumb:", JSON.stringify(enrichedBreadcrumb));
+		} catch {}
+	}
+	withScope(callback) {
+		if (!this.enabled) return;
+		try {
+			callback({
+				setContext: (key, context) => {
+					console.log(this.prefix, "Context set:", key, JSON.stringify(context));
+				},
+				setUser: (user) => {
+					this.setUser(user);
+				}
+			});
+		} catch {}
+	}
+	async flush() {
+		if (this.enabled) console.log(this.prefix, "Flushed");
+		return true;
+	}
+	formatContext(context) {
+		if (!context) return {};
+		if (context.extra !== void 0 || context.tags !== void 0) return {
+			context: context.extra,
+			tags: context.tags
+		};
+		if ("operation" in context || "metadata" in context) return {
+			context: context.metadata ?? {},
+			tags: { operation: context.operation }
+		};
+		return {
+			context,
+			tags: {}
+		};
+	}
+	/**
+	* Get CSS color style for browser console
+	* @param level - Log level
+	* @returns CSS style string
+	*/
+	getBrowserColorCSS(level) {
+		return {
+			debug: "color: #00CED1; font-weight: bold",
+			info: "color: #32CD32; font-weight: bold",
+			warning: "color: #FFA500; font-weight: bold",
+			error: "color: #DC143C; font-weight: bold"
+		}[level] ?? "color: inherit";
+	}
+	/**
+	* Get ANSI color code for Node.js terminal
+	* @param level - Log level
+	* @returns ANSI escape code
+	*/
+	getAnsiColorCode(level) {
+		return {
+			debug: "\x1B[36m",
+			info: "\x1B[32m",
+			warning: "\x1B[33m",
+			error: "\x1B[31m"
+		}[level] ?? "";
+	}
+	/**
+	* Get the console method name for a log level.
+	*
+	* @param level - Log level
+	* @returns Console method name ('debug', 'info', 'warn', or 'error')
+	*/
+	getLogMethod(level) {
+		switch (level) {
+			case "debug": return "debug";
+			case "info": return "info";
+			case "warning": return "warn";
+			case "error": return "error";
+			default: return "info";
+		}
+	}
+	/**
+	* Get a human-readable label for a log level.
+	*
+	* @param level - Log level
+	* @returns Capitalized level label ('Debug', 'Info', 'Warning', 'Error')
+	*/
+	getLevelLabel(level) {
+		switch (level) {
+			case "debug": return "Debug";
+			case "info": return "Info";
+			case "warning": return "Warning";
+			case "error": return "Error";
+			default: return "Info";
+		}
+	}
+};
+/**
+* Factory function to create a console plugin for browser environments.
+*
+* @param config - Console plugin configuration
+* @returns ConsolePlugin instance configured for browser
+*/
+const createConsolePlugin = (config) => {
+	return new ConsolePlugin(config);
+};
+
+//#endregion
+//#region ../observability/src/plugins/sentry/env.ts
+/**
+* @fileoverview Sentry-specific environment configuration
+* Sentry-specific environment configuration
+* Apps can extend this configuration to inherit Sentry environment variables
+*/
+const env = createEnv({
+	server: {
+		SENTRY_DSN: z.string().url().optional(),
+		SENTRY_AUTH_TOKEN: z.string().optional(),
+		SENTRY_ORG: z.string().optional(),
+		SENTRY_PROJECT: z.string().optional(),
+		SENTRY_ENVIRONMENT: z.enum([
+			"development",
+			"preview",
+			"production"
+		]).optional(),
+		SENTRY_RELEASE: z.string().optional(),
+		SENTRY_TRACES_SAMPLE_RATE: z.coerce.number().min(0).max(1).optional(),
+		SENTRY_PROFILES_SAMPLE_RATE: z.coerce.number().min(0).max(1).optional(),
+		SENTRY_REPLAYS_SESSION_SAMPLE_RATE: z.coerce.number().min(0).max(1).optional(),
+		SENTRY_REPLAYS_ON_ERROR_SAMPLE_RATE: z.coerce.number().min(0).max(1).optional(),
+		SENTRY_DEBUG: z.string().optional().transform((val) => val === "true").default(false)
+	},
+	clientPrefix: "NEXT_PUBLIC_",
+	client: {
+		NEXT_PUBLIC_SENTRY_DSN: z.string().url().optional(),
+		NEXT_PUBLIC_SENTRY_ENVIRONMENT: z.enum([
+			"development",
+			"preview",
+			"production"
+		]).optional(),
+		NEXT_PUBLIC_SENTRY_RELEASE: z.string().optional()
+	},
+	runtimeEnv: process.env,
+	emptyStringAsUndefined: true,
+	onInvalidAccess: (variable) => {
+		throw new Error(`❌ Attempted to access a server-side environment variable on the client: ${variable}`);
+	},
+	onValidationError: (error) => {
+		logWarn("Sentry environment validation failed", { error });
+	}
+});
+/**
+* Safe environment access for non-Next.js contexts.
+*
+* Provides fallback environment variable access for Node.js, workers, and test environments
+* where the validated env object may not be available. Returns fallback values with proper
+* type coercion and defaults.
+*
+* @returns Environment object with Sentry configuration values
+*/
+function safeEnv() {
+	if (env) return env;
+	return {
+		SENTRY_DSN: process.env.SENTRY_DSN ?? "",
+		SENTRY_AUTH_TOKEN: process.env.SENTRY_AUTH_TOKEN ?? "",
+		SENTRY_ORG: process.env.SENTRY_ORG ?? "",
+		SENTRY_PROJECT: process.env.SENTRY_PROJECT ?? "",
+		SENTRY_ENVIRONMENT: process.env.SENTRY_ENVIRONMENT ?? "development",
+		SENTRY_RELEASE: process.env.SENTRY_RELEASE ?? "",
+		SENTRY_TRACES_SAMPLE_RATE: Number(process.env.SENTRY_TRACES_SAMPLE_RATE) || 1,
+		SENTRY_PROFILES_SAMPLE_RATE: Number(process.env.SENTRY_PROFILES_SAMPLE_RATE) ?? 0,
+		SENTRY_REPLAYS_SESSION_SAMPLE_RATE: Number(process.env.SENTRY_REPLAYS_SESSION_SAMPLE_RATE) || 0,
+		SENTRY_REPLAYS_ON_ERROR_SAMPLE_RATE: Number(process.env.SENTRY_REPLAYS_ON_ERROR_SAMPLE_RATE) || 1,
+		SENTRY_DEBUG: process.env.SENTRY_DEBUG === "true",
+		NEXT_PUBLIC_SENTRY_DSN: process.env.NEXT_PUBLIC_SENTRY_DSN ?? "",
+		NEXT_PUBLIC_SENTRY_ENVIRONMENT: process.env.NEXT_PUBLIC_SENTRY_ENVIRONMENT ?? "development",
+		NEXT_PUBLIC_SENTRY_RELEASE: process.env.NEXT_PUBLIC_SENTRY_RELEASE ?? ""
+	};
+}
+
+//#endregion
+//#region ../observability/src/plugins/sentry/plugin.ts
+/**
+* @fileoverview Sentry plugin implementation
+* Sentry plugin implementation
+*/
+/**
+* Default log filter function that filters out noisy development logs.
+* Filters out:
+* - Next.js Fast Refresh messages
+* - HMR (Hot Module Replacement) messages
+* - Prisma query logs (server-only)
+* - Prisma engine/info logs
+* - SQL queries matching Prisma's format
+*
+* Handles ANSI color codes, console formatting (%c, %s), and CSS styling.
+*
+* @param log - The log entry from Sentry
+* @param isServer - Whether this is running on the server (defaults to true)
+* @returns The log entry if it should be sent, or null to filter it out
+*/
+function defaultBeforeSendLog(log, isServer = true) {
+	const messageToCheck = log.message || log.formatted || "";
+	if (!messageToCheck) return log;
+	const messageWithoutAnsi = String(messageToCheck).replace(/\u001b\[[0-9;]*m/g, "").replace(/%[csdfiO]/g, "").replace(/background:[^;]+;?/g, "").replace(/color:[^;]+;?/g, "").replace(/border-radius:[^;]+;?/g, "").replace(/light-dark\([^)]+\)/g, "").replace(/rgba?\([^)]+\)/g, "").replace(/#[0-9a-fA-F]{3,8}/g, "").toLowerCase();
+	if (messageWithoutAnsi.includes("[fast refresh]") || messageWithoutAnsi.includes("[hmr]")) return null;
+	if (isServer) {
+		if (messageWithoutAnsi.includes("prisma:query") || messageWithoutAnsi.includes("prisma:engine") || messageWithoutAnsi.includes("prisma:info") || messageWithoutAnsi.includes("select") && messageWithoutAnsi.includes("from") && (messageWithoutAnsi.includes("\"public\".") || messageWithoutAnsi.includes("public."))) return null;
+	}
+	return log;
+}
+/**
+* Sentry plugin implementation
+*/
+/**
+* Sentry plugin implementation.
+*
+* Integrates Sentry error tracking and performance monitoring into the observability system.
+* Auto-detects the appropriate Sentry package (@sentry/node, @sentry/browser, @sentry/nextjs)
+* based on the runtime environment.
+*/
+var SentryPlugin = class {
+	name = "sentry";
+	enabled;
+	client;
+	initialized = false;
+	sentryPackage;
+	config;
+	/**
+	* Create a new SentryPlugin instance.
+	*
+	* @param config - Sentry plugin configuration
+	*/
+	constructor(config = {}) {
+		this.config = config;
+		const env = safeEnv();
+		const hasDSN = config.dsn ?? env.SENTRY_DSN ?? env.NEXT_PUBLIC_SENTRY_DSN;
+		this.enabled = config.enabled ?? Boolean(hasDSN);
+		this.sentryPackage = config.sentryPackage ?? this.detectSentryPackage();
+	}
+	/**
+	* Detect which Sentry package to use based on the runtime environment.
+	*
+	* @returns Package name ('@sentry/node', '@sentry/browser', or '@sentry/nextjs')
+	*/
+	detectSentryPackage() {
+		if (isBrowser()) return "@sentry/browser";
+		else if (process.env.NEXT_RUNTIME === "edge") return "@sentry/nextjs";
+		else if (process.env.NEXT_RUNTIME) return "@sentry/nextjs";
+		else return "@sentry/node";
+	}
+	getClient() {
+		return this.client;
+	}
+	/**
+	* Get safe environment access (for testing/mocking).
+	*
+	* @returns Environment configuration object
+	*/
+	getSafeEnv() {
+		return safeEnv();
+	}
+	async initialize(config) {
+		if (this.initialized || !this.enabled) return;
+		const env = safeEnv();
+		const mergedConfig = {
+			...this.config,
+			...config
+		};
+		const dsn = mergedConfig.dsn ?? env.SENTRY_DSN ?? env.NEXT_PUBLIC_SENTRY_DSN;
+		if (!dsn) {
+			logWarn("Sentry plugin: No DSN provided, skipping initialization");
+			this.enabled = false;
+			return;
+		}
+		try {
+			this.client = await import(
+				/* webpackIgnore: true */
+				this.sentryPackage
+);
+			if (this.client && this.enabled) {
+				let { integrations } = mergedConfig;
+				if (!integrations && this.client.browserTracingIntegration) {
+					integrations = [];
+					if (mergedConfig.tracesSampleRate !== void 0 || env.SENTRY_TRACES_SAMPLE_RATE !== void 0) integrations.push(this.client.browserTracingIntegration());
+					if (this.client.replayIntegration && (mergedConfig.replaysSessionSampleRate !== void 0 || env.SENTRY_REPLAYS_SESSION_SAMPLE_RATE !== void 0)) integrations.push(this.client.replayIntegration());
+					if (this.client.profilesIntegration && (mergedConfig.profilesSampleRate !== void 0 || env.SENTRY_PROFILES_SAMPLE_RATE !== void 0)) integrations.push(this.client.profilesIntegration());
+				}
+				const enableLogs = mergedConfig.enableLogs ?? true;
+				if (enableLogs && this.client.consoleLoggingIntegration) {
+					const consoleLoggingConfig = mergedConfig.consoleLoggingIntegration || { levels: [
+						"log",
+						"warn",
+						"error"
+					] };
+					if (!integrations) integrations = [];
+					integrations.push(this.client.consoleLoggingIntegration(consoleLoggingConfig));
+				}
+				this.client.init({
+					dsn,
+					environment: mergedConfig.environment ?? env.SENTRY_ENVIRONMENT ?? "development",
+					release: mergedConfig.release ?? env.SENTRY_RELEASE,
+					debug: mergedConfig.debug ?? env.SENTRY_DEBUG,
+					enableLogs,
+					tracesSampleRate: mergedConfig.tracesSampleRate ?? env.SENTRY_TRACES_SAMPLE_RATE,
+					profilesSampleRate: mergedConfig.profilesSampleRate ?? env.SENTRY_PROFILES_SAMPLE_RATE,
+					replaysSessionSampleRate: mergedConfig.replaysSessionSampleRate ?? env.SENTRY_REPLAYS_SESSION_SAMPLE_RATE,
+					replaysOnErrorSampleRate: mergedConfig.replaysOnErrorSampleRate ?? env.SENTRY_REPLAYS_ON_ERROR_SAMPLE_RATE,
+					integrations,
+					beforeSend: mergedConfig.beforeSend,
+					beforeSendTransaction: mergedConfig.beforeSendTransaction,
+					beforeSendLog: mergedConfig.beforeSendLog || (enableLogs ? (log) => defaultBeforeSendLog(log, !isBrowser()) : void 0),
+					tracePropagationTargets: mergedConfig.tracePropagationTargets,
+					initialScope: mergedConfig.initialScope,
+					maxBreadcrumbs: mergedConfig.maxBreadcrumbs,
+					attachStacktrace: mergedConfig.attachStacktrace,
+					autoSessionTracking: mergedConfig.autoSessionTracking
+				});
+				this.initialized = true;
+			}
+		} catch (error) {
+			logError(`Failed to import Sentry package '${this.sentryPackage}'`, { error });
+			this.enabled = false;
+		}
+	}
+	async shutdown() {
+		if (this.client && this.initialized) {
+			if (this.client.close) await this.client.close();
+			else if (this.client.flush) await this.client.flush();
+			this.initialized = false;
+		}
+	}
+	/**
+	* Clean up the plugin (alias for shutdown)
+	*/
+	async cleanup() {
+		await this.shutdown();
+	}
+	captureException(error, context) {
+		if (!this.enabled || !this.client) return;
+		if (typeof this.client.captureException !== "function") {
+			logError("[Sentry Fallback] Exception", { error });
+			return;
+		}
+		try {
+			this.client.captureException(error, context);
+		} catch (captureError) {
+			logWarn("[Sentry Plugin] Failed to capture exception", { error: captureError });
+			logError("[Sentry Fallback] Exception", { error });
+		}
+	}
+	captureMessage(message, level = "info", context) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.logger) try {
+			const attributes = context ? context.extra ?? context : void 0;
+			switch (level) {
+				case "debug":
+					this.client.logger.debug(message, attributes);
+					return;
+				case "info":
+					this.client.logger.info(message, attributes);
+					return;
+				case "warning":
+					this.client.logger.warn(message, attributes);
+					return;
+				case "error":
+					this.client.logger.error(message, attributes);
+					return;
+			}
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to log via logger", { error });
+		}
+		if (typeof this.client.captureMessage !== "function") {
+			if (level === "error") logError(`[Sentry Fallback] ${message}`);
+			else if (level === "warning") logWarn(`[Sentry Fallback] ${message}`);
+			else logDebug(`[Sentry Fallback] ${message}`);
+			return;
+		}
+		const sentryLevel = level === "warning" ? "warning" : level === "error" ? "error" : level === "debug" ? "debug" : "info";
+		try {
+			const captureContext = context ? {
+				level: sentryLevel,
+				extra: context.extra ?? context,
+				tags: context.tags
+			} : sentryLevel;
+			this.client.captureMessage(message, captureContext);
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to capture message", { error });
+			if (level === "error") logError(`[Sentry Fallback] ${message}`);
+			else if (level === "warning") logWarn(`[Sentry Fallback] ${message}`);
+			else logDebug(`[Sentry Fallback] ${message}`);
+		}
+	}
+	setUser(user) {
+		if (!this.enabled || !this.client) return;
+		this.client.setUser(user);
+	}
+	addBreadcrumb(breadcrumb) {
+		if (!this.enabled || !this.client) return;
+		this.client.addBreadcrumb({
+			...breadcrumb,
+			timestamp: breadcrumb.timestamp ?? Date.now() / 1e3
+		});
+	}
+	withScope(callback) {
+		if (!this.enabled || !this.client) return;
+		this.client.withScope(callback);
+	}
+	/**
+	* Start a new transaction
+	*/
+	startTransaction(context, customSamplingContext) {
+		if (!this.enabled || !this.client) return void 0;
+		if (this.client.startTransaction) return this.client.startTransaction(context, customSamplingContext);
+		logWarn("startTransaction not available in this Sentry version");
+	}
+	/**
+	* Start a new span
+	*/
+	startSpan(context) {
+		if (!this.enabled || !this.client) return void 0;
+		if (this.client.startSpan) return this.client.startSpan(context);
+		const transaction = this.getActiveTransaction();
+		if (transaction?.startChild) return transaction.startChild(context);
+	}
+	/**
+	* Get the currently active transaction
+	*/
+	getActiveTransaction() {
+		if (!this.enabled || !this.client) return void 0;
+		if (this.client.getActiveTransaction) return this.client.getActiveTransaction();
+		if (this.client.getCurrentScope) {
+			const scope = this.client.getCurrentScope();
+			if (scope?.getTransaction) return scope.getTransaction();
+		}
+	}
+	/**
+	* Configure the current scope
+	*/
+	configureScope(callback) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.configureScope) this.client.configureScope(callback);
+		else if (this.client.withScope) this.client.withScope(callback);
+	}
+	/**
+	* Get the current hub instance
+	*/
+	getCurrentHub() {
+		if (!this.enabled || !this.client) return void 0;
+		if (this.client.getCurrentHub) return this.client.getCurrentHub();
+	}
+	/**
+	* Set a measurement on the active transaction
+	*/
+	setMeasurement(name, value, unit) {
+		if (!this.enabled || !this.client) return;
+		const transaction = this.getActiveTransaction();
+		if (transaction?.setMeasurement) transaction.setMeasurement(name, value, unit);
+	}
+	/**
+	* Add performance entries as breadcrumbs and measurements
+	*/
+	addPerformanceEntries(entries) {
+		if (!this.enabled || !this.client) return;
+		const transaction = this.getActiveTransaction();
+		entries.forEach((entry) => {
+			this.addBreadcrumb({
+				category: "performance",
+				message: `${entry.entryType}: ${entry.name}`,
+				data: {
+					name: entry.name,
+					duration: entry.duration,
+					startTime: entry.startTime,
+					...entry.entryType === "navigation" && {
+						transferSize: entry.transferSize,
+						encodedBodySize: entry.encodedBodySize,
+						decodedBodySize: entry.decodedBodySize
+					},
+					...entry.entryType === "resource" && {
+						initiatorType: entry.initiatorType,
+						transferSize: entry.transferSize
+					}
+				}
+			});
+			if (transaction && entry.entryType === "navigation") {
+				const navEntry = entry;
+				const fetchStart = navEntry.fetchStart ?? 0;
+				if (navEntry.responseStart !== void 0) this.setMeasurement("fcp", navEntry.responseStart - fetchStart, "millisecond");
+				if (navEntry.domInteractive !== void 0) this.setMeasurement("dom_interactive", navEntry.domInteractive - fetchStart, "millisecond");
+				if (navEntry.domComplete !== void 0) this.setMeasurement("dom_complete", navEntry.domComplete - fetchStart, "millisecond");
+				if (navEntry.loadEventEnd !== void 0) this.setMeasurement("load_event_end", navEntry.loadEventEnd - fetchStart, "millisecond");
+			}
+		});
+	}
+	/**
+	* Record a Web Vital measurement
+	*/
+	recordWebVital(name, value, options) {
+		if (!this.enabled || !this.client) return;
+		const { unit = "millisecond", rating } = options ?? {};
+		const transaction = this.getActiveTransaction();
+		if (transaction) {
+			transaction.setMeasurement(name.toLowerCase(), value, unit);
+			if (rating) transaction.setTag(`webvital.${name.toLowerCase()}.rating`, rating);
+			this.client.captureMessage(`Web Vital: ${name}`, {
+				level: "info",
+				tags: {
+					"webvital.name": name,
+					"webvital.value": value,
+					"webvital.unit": unit,
+					...rating && { "webvital.rating": rating }
+				},
+				contexts: { trace: {
+					trace_id: transaction.traceId,
+					span_id: transaction.spanId
+				} }
+			});
+		}
+	}
+	/**
+	* Create a custom performance mark
+	*/
+	mark(name, options) {
+		if (!this.enabled) return;
+		if (typeof performance !== "undefined" && performance.mark) performance.mark(name, options);
+		this.addBreadcrumb({
+			category: "performance.mark",
+			message: name,
+			data: options?.detail,
+			timestamp: Date.now() / 1e3
+		});
+	}
+	/**
+	* Create a custom performance measure
+	*/
+	measure(name, startMarkOrOptions, endMark) {
+		if (!this.enabled) return;
+		if (typeof performance !== "undefined" && performance.measure) {
+			if (typeof startMarkOrOptions === "string") performance.measure(name, startMarkOrOptions, endMark);
+			else if (startMarkOrOptions) performance.measure(name, startMarkOrOptions);
+			else performance.measure(name);
+			const measures = performance.getEntriesByName(name, "measure");
+			const measure = measures[measures.length - 1];
+			if (measure) {
+				this.setMeasurement(name, measure.duration, "millisecond");
+				this.addBreadcrumb({
+					category: "performance.measure",
+					message: name,
+					data: {
+						duration: measure.duration,
+						startTime: measure.startTime
+					},
+					timestamp: measure.startTime / 1e3
+				});
+			}
+		}
+	}
+	/**
+	* Log a trace message using Sentry.logger (if available).
+	* Falls back to captureMessage if logger is not available.
+	*
+	* @param message - Trace message to log
+	* @param attributes - Optional attributes to include with the log
+	*/
+	logTrace(message, attributes) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.logger?.trace) try {
+			this.client.logger.trace(message, attributes);
+			return;
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to log trace", { error });
+		}
+		this.captureMessage(message, "debug", attributes);
+	}
+	/**
+	* Log a debug message using Sentry.logger (if available).
+	* Falls back to captureMessage if logger is not available.
+	*
+	* @param message - Debug message to log
+	* @param attributes - Optional attributes to include with the log
+	*/
+	logDebug(message, attributes) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.logger?.debug) try {
+			this.client.logger.debug(message, attributes);
+			return;
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to log debug", { error });
+		}
+		this.captureMessage(message, "debug", attributes);
+	}
+	/**
+	* Log an info message using Sentry.logger (if available).
+	* Falls back to captureMessage if logger is not available.
+	*
+	* @param message - Info message to log
+	* @param attributes - Optional attributes to include with the log
+	*/
+	logInfo(message, attributes) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.logger?.info) try {
+			this.client.logger.info(message, attributes);
+			return;
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to log info", { error });
+		}
+		this.captureMessage(message, "info", attributes);
+	}
+	/**
+	* Log a warning message using Sentry.logger (if available).
+	* Falls back to captureMessage if logger is not available.
+	*
+	* @param message - Warning message to log
+	* @param attributes - Optional attributes to include with the log
+	*/
+	logWarn(message, attributes) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.logger?.warn) try {
+			this.client.logger.warn(message, attributes);
+			return;
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to log warn", { error });
+		}
+		this.captureMessage(message, "warning", attributes);
+	}
+	/**
+	* Log an error message using Sentry.logger (if available).
+	* Falls back to captureMessage if logger is not available.
+	*
+	* @param message - Error message to log
+	* @param attributes - Optional attributes to include with the log
+	*/
+	logError(message, attributes) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.logger?.error) try {
+			this.client.logger.error(message, attributes);
+			return;
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to log error", { error });
+		}
+		this.captureMessage(message, "error", attributes);
+	}
+	/**
+	* Log a fatal message using Sentry.logger (if available).
+	* Falls back to captureMessage if logger is not available.
+	*
+	* @param message - Fatal message to log
+	* @param attributes - Optional attributes to include with the log
+	*/
+	logFatal(message, attributes) {
+		if (!this.enabled || !this.client) return;
+		if (this.client.logger?.fatal) try {
+			this.client.logger.fatal(message, attributes);
+			return;
+		} catch (error) {
+			logWarn("[Sentry Plugin] Failed to log fatal", { error });
+		}
+		this.captureMessage(message, "error", attributes);
+	}
+	/**
+	* Get the Sentry.logger instance if available.
+	* This allows direct access to Sentry.logger APIs including fmt.
+	*
+	* @returns Sentry.logger instance or undefined if not available
+	*
+	* @example
+	* ```typescript
+	* const logger = sentryPlugin.getLogger();
+	* if (logger) {
+	*   logger.info(logger.fmt`User ${user.id} logged in`);
+	* }
+	* ```
+	*/
+	getLogger() {
+		if (!this.enabled || !this.client) return void 0;
+		return this.client.logger;
+	}
+	async flush(timeout) {
+		if (!this.enabled || !this.client || !this.client.flush) return true;
+		try {
+			return await this.client.flush(timeout);
+		} catch (_error) {
+			return false;
+		}
+	}
+};
+/**
+* Factory function to create a Sentry plugin.
+*
+* Creates a configured SentryPlugin instance with optional configuration.
+* Auto-detects the appropriate Sentry package based on the environment.
+*
+* @param config - Optional Sentry plugin configuration
+* @returns SentryPlugin instance
+*
+* @example
+* ```typescript
+* const sentry = createSentryPlugin({
+*   dsn: 'https://...',
+*   environment: 'production',
+*   tracesSampleRate: 0.1,
+* });
+* ```
+*/
+const createSentryPlugin = (config) => {
+	return new SentryPlugin(config);
+};
+
+//#endregion
+//#region ../observability/src/client-next.ts
+/**
+* @fileoverview Next.js client-specific observability export
+* Next.js client-specific observability export
+*/
+/**
+* Create auto-configured observability for Next.js client
+*/
+async function createClientObservability() {
+	const builder = ObservabilityBuilder.create();
+	const enableConsole = shouldEnableConsole(env$2.NEXT_PUBLIC_NODE_ENV, env$2.NEXT_PUBLIC_OBSERVABILITY_CONSOLE_ENABLED, env$2.NEXT_PUBLIC_OBSERVABILITY_DEBUG);
+	builder.withPlugin(createConsolePlugin({
+		prefix: "[Next.js Client]",
+		enabled: enableConsole
+	}));
+	if (env.NEXT_PUBLIC_SENTRY_DSN) builder.withPlugin(createSentryPlugin({ dsn: env.NEXT_PUBLIC_SENTRY_DSN }));
+	const clientBetterStackToken = env$1.NEXT_PUBLIC_BETTER_STACK_SOURCE_TOKEN ?? env$1.NEXT_PUBLIC_BETTERSTACK_TOKEN ?? env$1.NEXT_PUBLIC_LOGTAIL_TOKEN;
+	if (clientBetterStackToken) builder.withPlugin(createBetterStackPlugin({ sourceToken: clientBetterStackToken }));
+	return builder.build();
 }
 
 //#endregion
@@ -317,7 +1903,6 @@ function resetAnalytics() {
 *
 * @module @od-oneapp/analytics/client/next/components
 */
-let globalAnalytics = null;
 let logger = null;
 /**
 * Analytics provider component for App Router.
@@ -352,11 +1937,11 @@ let logger = null;
 */
 function AnalyticsProvider({ autoPageTracking = true, children, config, pageTrackingOptions }) {
 	useEffect(() => {
-		if (!globalAnalytics) {
+		if (!getGlobalAnalytics()) {
 			const initAnalytics = async () => {
 				try {
 					logger ??= await createClientObservability();
-					globalAnalytics = await createNextJSClientAnalytics(config);
+					setGlobalAnalytics(await createNextJSClientAnalytics(config));
 				} catch (error) {
 					if (logger) logger.captureException(error, { message: "Failed to initialize analytics" });
 				}