@od-oneapp/analytics 2026.1.1301

package/dist/posthog-bootstrap-CYfIy_WS.mjs

@@ -0,0 +1,1769 @@
+import { i as page, n as group, o as track, r as identify, t as alias } from "./emitters-6-nKo8i-.mjs";
+import { logWarn } from "@od-oneapp/shared/logger";
+
+//#region src/shared/utils/rate-limit.ts
+/**
+* @fileoverview Rate limiting utilities for analytics calls
+* Rate limiting utilities for analytics calls
+*
+* Prevents overwhelming provider APIs, hitting rate limits, and excessive costs.
+* Uses token bucket algorithm for smooth rate limiting with bursts.
+*
+* @module rate-limit
+*/
+/**
+* Rate limiter for analytics calls
+*
+* Implements token bucket algorithm with optional call queuing.
+*
+* @example
+* ```typescript
+* const limiter = new RateLimiter({
+*   maxCalls: 100,
+*   windowMs: 1000, // 100 calls per second
+*   maxConcurrent: 10,
+* });
+*
+* // Check if call is allowed
+* if (await limiter.tryAcquire()) {
+*   await analytics.track('Event');
+*   limiter.release();
+* }
+*
+* // Or use wrapper
+* await limiter.execute(() => analytics.track('Event'));
+* ```
+*/
+var RateLimiter = class {
+	callCount = 0;
+	concurrentCount = 0;
+	windowStart = Date.now();
+	queue = [];
+	config;
+	constructor(config) {
+		this.config = {
+			maxCalls: config.maxCalls,
+			windowMs: config.windowMs,
+			maxConcurrent: config.maxConcurrent ?? Infinity,
+			queueExcess: config.queueExcess ?? false,
+			maxQueueSize: config.maxQueueSize ?? 1e3
+		};
+	}
+	/**
+	* Try to acquire a rate limit token
+	*
+	* @returns Promise resolving to whether the call is allowed
+	*/
+	async tryAcquire() {
+		const now = Date.now();
+		if (now - this.windowStart >= this.config.windowMs) {
+			this.callCount = 0;
+			this.windowStart = now;
+		}
+		if (this.callCount >= this.config.maxCalls) {
+			if (this.config.queueExcess && this.queue.length < this.config.maxQueueSize) return new Promise((resolve) => {
+				this.queue.push(() => {
+					const now = Date.now();
+					if (now - this.windowStart >= this.config.windowMs) {
+						this.callCount = 0;
+						this.windowStart = now;
+					}
+					if (this.callCount < this.config.maxCalls) {
+						this.callCount++;
+						resolve(true);
+					} else resolve(false);
+				});
+			});
+			logWarn("Rate limit exceeded", {
+				maxCalls: this.config.maxCalls,
+				windowMs: this.config.windowMs,
+				currentCount: this.callCount
+			});
+			return false;
+		}
+		if (this.concurrentCount >= this.config.maxConcurrent) {
+			if (this.config.queueExcess && this.queue.length < this.config.maxQueueSize) return new Promise((resolve) => {
+				this.queue.push(() => resolve(true));
+			});
+			return false;
+		}
+		this.callCount++;
+		this.concurrentCount++;
+		return true;
+	}
+	/**
+	* Release a rate limit token
+	*/
+	release() {
+		this.concurrentCount = Math.max(0, this.concurrentCount - 1);
+		if (this.queue.length > 0 && this.concurrentCount < this.config.maxConcurrent) {
+			const now = Date.now();
+			if (now - this.windowStart >= this.config.windowMs) {
+				this.callCount = 0;
+				this.windowStart = now;
+			}
+			if (this.callCount < this.config.maxCalls) {
+				const next = this.queue.shift();
+				if (next) {
+					this.concurrentCount++;
+					next();
+				}
+			}
+		}
+	}
+	/**
+	* Execute a function with rate limiting
+	*
+	* @param fn - Function to execute
+	* @returns Promise resolving to function result
+	*/
+	async execute(fn) {
+		if (!await this.tryAcquire()) return null;
+		try {
+			return await fn();
+		} finally {
+			this.release();
+		}
+	}
+	/**
+	* Get current rate limiter stats
+	*/
+	getStats() {
+		return {
+			callCount: this.callCount,
+			concurrentCount: this.concurrentCount,
+			queueSize: this.queue.length,
+			remainingCalls: Math.max(0, this.config.maxCalls - this.callCount),
+			windowStart: this.windowStart
+		};
+	}
+	/**
+	* Reset the rate limiter
+	*/
+	reset() {
+		this.callCount = 0;
+		this.concurrentCount = 0;
+		this.windowStart = Date.now();
+		this.queue = [];
+	}
+};
+
+//#endregion
+//#region src/shared/utils/security.ts
+/**
+* @fileoverview Security and sanitization utilities for analytics data
+*
+* This module provides comprehensive security utilities for analytics data:
+*
+* - **PII Detection**: Detects personally identifiable information (emails, phones, SSNs, credit cards, IPs)
+* - **PII Redaction**: Redacts PII from strings before sending to analytics
+* - **XSS Protection**: Strips HTML and script tags to prevent XSS attacks
+* - **Property Validation**: Validates property keys to prevent prototype pollution
+* - **Payload Sanitization**: Comprehensive sanitization with size limits and depth checks
+* - **Size Limits**: Enforces maximum property and payload sizes
+*
+* **Security Features**:
+* - Maximum property value size: 100KB
+* - Maximum payload size: 1MB
+* - Maximum nesting depth: 10 levels
+* - Dangerous key filtering (prevents prototype pollution)
+* - HTML/script tag removal
+*
+* @module @od-oneapp/analytics/shared/utils/security
+*/
+/**
+* Maximum allowed property value size (100KB).
+*
+* Prevents sending excessively large property values to analytics providers.
+*
+* @internal
+*/
+const MAX_PROPERTY_VALUE_SIZE = 100 * 1024;
+/**
+* Maximum allowed total payload size (1MB).
+*
+* Prevents sending excessively large payloads to analytics providers.
+*
+* @internal
+*/
+const MAX_PAYLOAD_SIZE = 1024 * 1024;
+/**
+* Maximum allowed object nesting depth.
+*
+* Prevents deeply nested objects that could cause performance issues or stack overflows.
+*
+* @internal
+*/
+const MAX_DEPTH = 10;
+/**
+* PII patterns for detection and filtering
+* Note: These regexes are intentionally complex for accurate PII detection.
+* They are used only on bounded, sanitized input with size limits.
+*/
+const PII_PATTERNS = {
+	email: /\b[\w%+.-]+@[\d.A-Za-z-]+\.[A-Za-z|]{2,}\b/g,
+	phone: /\b(?:\+?1[.-]?)?\(?(\d{3})\)?[.-]?(\d{3})[.-]?(\d{4})\b/g,
+	ssn: /\b\d{3}-?\d{2}-?\d{4}\b/g,
+	creditCard: /\b(?:\d{4}[ -]?){3}\d{4}\b/g,
+	ipv4: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+	ipv6: /\b(?:[\da-f]{1,4}:){7}[\da-f]{1,4}\b/gi
+};
+/**
+* Dangerous property keys that should never be allowed
+*/
+const DANGEROUS_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype",
+	"__defineGetter__",
+	"__defineSetter__",
+	"__lookupGetter__",
+	"__lookupSetter__"
+]);
+/**
+* HTML/Script patterns for XSS protection
+* Note: These regexes are intentionally complex for accurate XSS detection.
+* They are used only on bounded, sanitized input with size limits.
+*/
+const XSS_PATTERNS = {
+	scriptTag: /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+	onEvent: /\bon\w+\s*=\s*["'][^"']*["']/gi,
+	javascript: /javascript:/gi,
+	dataUri: /data:text\/html/gi
+};
+/**
+* Check if a value contains PII (Personally Identifiable Information).
+*
+* Detects common PII patterns including:
+* - Email addresses
+* - Phone numbers
+* - Social Security Numbers
+* - Credit card numbers
+* - IPv4 and IPv6 addresses
+*
+* @param {string} value - String value to check for PII
+* @returns {boolean} `true` if PII is detected, `false` otherwise
+*
+* @example
+* ```typescript
+* if (containsPII(userInput)) {
+*   const sanitized = redactPII(userInput);
+*   // Use sanitized value
+* }
+* ```
+*/
+function containsPII(value) {
+	return Object.values(PII_PATTERNS).some((pattern) => pattern.test(value));
+}
+/**
+* Redact PII from a string.
+*
+* Replaces detected PII patterns with `[REDACTED_TYPE]` placeholders.
+* Useful for logging or analytics where PII should not be stored.
+*
+* @param {string} value - String value to redact PII from
+* @returns {string} String with PII redacted
+*
+* @example
+* ```typescript
+* const sanitized = redactPII('Contact john@example.com at 555-1234');
+* // Returns: 'Contact [REDACTED_EMAIL] at [REDACTED_PHONE]'
+* ```
+*/
+function redactPII(value) {
+	let redacted = value;
+	for (const [type, pattern] of Object.entries(PII_PATTERNS)) redacted = redacted.replace(pattern, `[REDACTED_${type.toUpperCase()}]`);
+	return redacted;
+}
+/**
+* Strip HTML and script tags from a string.
+*
+* Removes HTML tags, script tags, event handlers, and other potentially dangerous
+* content to prevent XSS attacks. Also removes `data:text/html` URIs.
+*
+* @param {string} value - String value to strip HTML from
+* @returns {string} String with HTML and scripts removed
+*
+* @example
+* ```typescript
+* const sanitized = stripHTML('<script>alert("xss")<\/script>Hello');
+* // Returns: 'Hello'
+* ```
+*/
+function stripHTML(value) {
+	let stripped = value;
+	for (const pattern of Object.values(XSS_PATTERNS)) stripped = stripped.replace(pattern, "");
+	stripped = stripped.replaceAll(/<[^>]*>/g, "");
+	return stripped;
+}
+/**
+* Validate that a property key is safe.
+*
+* Checks for dangerous keys that could cause prototype pollution or other
+* security issues. Also validates against allowed key patterns if provided.
+*
+* @param {string} key - Property key to validate
+* @param {SanitizationOptions} [options] - Sanitization options
+* @returns {{ valid: boolean; reason?: string }} Validation result with reason if invalid
+*
+* @example
+* ```typescript
+* const result = isValidPropertyKey('__proto__');
+* if (!result.valid) {
+*   console.warn('Unsafe key:', result.reason);
+* }
+* ```
+*/
+function isValidPropertyKey(key, options = {}) {
+	if (!options.allowDangerousKeys && DANGEROUS_KEYS.has(key)) return {
+		valid: false,
+		reason: "Dangerous key that could cause prototype pollution"
+	};
+	if (options.allowedKeyPattern && !options.allowedKeyPattern.test(key)) return {
+		valid: false,
+		reason: "Key does not match allowed pattern"
+	};
+	if (/[<>[\\\]{}]/.test(key)) return {
+		valid: false,
+		reason: "Key contains potentially dangerous characters"
+	};
+	return { valid: true };
+}
+/**
+* Get the size of a value in bytes
+*/
+function getValueSize(value) {
+	if (typeof value === "string") return new Blob([value]).size;
+	try {
+		return new Blob([JSON.stringify(value)]).size;
+	} catch {
+		return 0;
+	}
+}
+/**
+* Sanitize a single property value
+*/
+function sanitizeValue(value, options, warnings) {
+	if (value === null || value === void 0) return {
+		value,
+		modified: false
+	};
+	let modified = false;
+	if (typeof value === "string") {
+		let sanitized = value;
+		const size = getValueSize(value);
+		const maxSize = options.maxPropertySize ?? MAX_PROPERTY_VALUE_SIZE;
+		if (size > maxSize) {
+			sanitized = value.slice(0, Math.max(0, maxSize));
+			warnings.push(`String value truncated from ${size} to ${maxSize} bytes`);
+			modified = true;
+		}
+		if (options.stripPII && containsPII(sanitized)) {
+			sanitized = redactPII(sanitized);
+			warnings.push("PII detected and redacted from value");
+			modified = true;
+		}
+		if (options.stripHTML) {
+			const stripped = stripHTML(sanitized);
+			if (stripped !== sanitized) {
+				sanitized = stripped;
+				warnings.push("HTML/scripts stripped from value");
+				modified = true;
+			}
+		}
+		return {
+			value: sanitized,
+			modified
+		};
+	}
+	if (typeof value !== "object") return {
+		value,
+		modified: false
+	};
+	return {
+		value,
+		modified: false
+	};
+}
+/**
+* Sanitize analytics properties recursively.
+*
+* Comprehensive sanitization of analytics properties including:
+* - Size limit enforcement
+* - Depth limit enforcement
+* - PII detection and redaction
+* - HTML/script tag removal
+* - Dangerous key filtering
+* - Circular reference detection
+*
+* @param {T} properties - Properties to sanitize
+* @param {SanitizationOptions} [options] - Sanitization options
+* @returns {SanitizationResult<T>} Sanitization result with sanitized data and warnings
+*
+* @throws {Error} If properties contain circular references or exceed payload size limit
+*
+* @example
+* ```typescript
+* const result = sanitizeProperties({
+*   user_email: 'test@example.com',
+*   phone: '555-1234',
+*   description: '<script>alert("xss")<\/script>Hello',
+* }, {
+*   stripPII: true,
+*   stripHTML: true,
+* });
+*
+* console.log(result.data);
+* // {
+* //   user_email: '[REDACTED_EMAIL]',
+* //   phone: '[REDACTED_PHONE]',
+* //   description: 'Hello'
+* // }
+* ```
+*/
+function sanitizeProperties(properties, options = {}) {
+	const warnings = [];
+	let modified = false;
+	try {
+		JSON.stringify(properties);
+	} catch {
+		throw new Error("Properties contain circular references");
+	}
+	const totalSize = getValueSize(properties);
+	const maxPayloadSize = options.maxPayloadSize ?? MAX_PAYLOAD_SIZE;
+	if (totalSize > maxPayloadSize) throw new Error(`Payload size ${totalSize} bytes exceeds maximum ${maxPayloadSize} bytes`);
+	/**
+	* Recursive sanitization helper
+	*/
+	function sanitizeRecursive(obj, depth = 0) {
+		const maxDepth = options.maxDepth ?? MAX_DEPTH;
+		if (depth > maxDepth) {
+			warnings.push(`Maximum nesting depth ${maxDepth} exceeded, truncating`);
+			modified = true;
+			return {};
+		}
+		const sanitized = {};
+		for (const [key, value] of Object.entries(obj)) {
+			const keyValidation = isValidPropertyKey(key, options);
+			if (!keyValidation.valid) {
+				warnings.push(`Skipping dangerous key "${key}": ${keyValidation.reason}`);
+				modified = true;
+				continue;
+			}
+			if (value === null || value === void 0) {
+				sanitized[key] = value;
+				continue;
+			}
+			if (Array.isArray(value)) {
+				sanitized[key] = value.map((item) => {
+					if (typeof item === "object" && item !== null) return sanitizeRecursive(item, depth + 1);
+					const result = sanitizeValue(item, options, warnings);
+					if (result.modified) modified = true;
+					return result.value;
+				});
+				continue;
+			}
+			if (typeof value === "object") {
+				sanitized[key] = sanitizeRecursive(value, depth + 1);
+				continue;
+			}
+			const result = sanitizeValue(value, options, warnings);
+			if (result.modified) modified = true;
+			sanitized[key] = result.value;
+		}
+		return sanitized;
+	}
+	const sanitized = sanitizeRecursive(properties);
+	if (warnings.length > 0 && true) logWarn("Analytics properties sanitization warnings", { warnings });
+	return {
+		data: sanitized,
+		modified,
+		warnings
+	};
+}
+/**
+* Validate event name.
+*
+* Checks that an event name is safe and follows best practices:
+* - Non-empty string
+* - Not exceeding 255 characters
+* - No XSS patterns
+*
+* @param {string} event - Event name to validate
+* @returns {{ valid: boolean; reason?: string }} Validation result with reason if invalid
+*
+* @example
+* ```typescript
+* const result = validateEventName('Button Clicked');
+* if (!result.valid) {
+*   console.error('Invalid event name:', result.reason);
+* }
+* ```
+*/
+function validateEventName(event) {
+	if (!event || typeof event !== "string") return {
+		valid: false,
+		reason: "Event name must be a non-empty string"
+	};
+	if (event.trim() === "") return {
+		valid: false,
+		reason: "Event name cannot be empty or whitespace only"
+	};
+	if (event.length > 255) return {
+		valid: false,
+		reason: "Event name cannot exceed 255 characters"
+	};
+	if (Object.values(XSS_PATTERNS).some((pattern) => pattern.test(event))) return {
+		valid: false,
+		reason: "Event name contains potentially malicious content"
+	};
+	return { valid: true };
+}
+
+//#endregion
+//#region src/shared/utils/manager.ts
+/**
+* @fileoverview Analytics Manager - Core orchestration for multi-provider analytics
+*
+* This module provides the core AnalyticsManager class that orchestrates multiple
+* analytics providers. It includes:
+*
+* - **Multi-Provider Support**: Manages multiple providers simultaneously
+* - **Event Deduplication**: LRU cache prevents duplicate events
+* - **Rate Limiting**: Per-provider rate limiting (100 calls/second default)
+* - **Batch Processing**: Concurrent batch processing with configurable concurrency
+* - **Performance Metrics**: Tracks provider performance and reliability
+* - **Error Handling**: Comprehensive error handling with graceful degradation
+*
+* **Node.js 22+ Features Used**:
+* - `Promise.withResolvers()`: External promise control for complex workflows
+* - `AbortSignal.timeout()`: Context-aware timeouts for provider operations
+* - High-resolution timing: Precise performance measurement (`process.hrtime.bigint()`)
+* - `Object.hasOwn()`: Safer property existence checks
+*
+* **Optimizations**:
+* - Spread operator instead of `structuredClone()` for better performance
+* - LRU cache for event deduplication (prevents memory leaks)
+* - Concurrent batch processing with configurable concurrency
+* - Comprehensive input sanitization and validation
+* - Per-provider rate limiting
+*
+* @module @od-oneapp/analytics/shared/utils/manager
+*/
+/**
+* LRU Cache for event deduplication.
+*
+* Prevents memory leaks by limiting cache size. Uses least-recently-used eviction
+* policy to maintain bounded memory usage.
+*
+* @template K - Cache key type
+* @template V - Cache value type
+*
+* @internal
+*/
+var LRUCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	constructor(maxSize = 1e3) {
+		this.maxSize = maxSize;
+	}
+	get(key) {
+		const value = this.cache.get(key);
+		if (value !== void 0) {
+			this.cache.delete(key);
+			this.cache.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (this.cache.has(key)) this.cache.delete(key);
+		this.cache.set(key, value);
+		if (this.cache.size > this.maxSize) {
+			const firstKey = this.cache.keys().next().value;
+			if (firstKey !== void 0) this.cache.delete(firstKey);
+		}
+	}
+	has(key) {
+		return this.cache.get(key) !== void 0;
+	}
+	clear() {
+		this.cache.clear();
+	}
+	get size() {
+		return this.cache.size;
+	}
+};
+/**
+* Analytics Manager - Main entry point for analytics tracking.
+*
+* Orchestrates multiple analytics providers, handles event deduplication,
+* rate limiting, batch processing, and error handling.
+*
+* **Key Features**:
+* - Multi-provider support (PostHog, Segment, Vercel, Console)
+* - Event deduplication via LRU cache
+* - Rate limiting (100 calls/second per provider)
+* - Batch processing with concurrency control
+* - Performance metrics tracking
+* - Graceful error handling
+*
+* **Usage**:
+* ```typescript
+* const manager = new AnalyticsManager(config, providerRegistry);
+* await manager.initialize();
+* await manager.emit(track('Event Name', { property: 'value' }));
+* ```
+*/
+var AnalyticsManager = class {
+	providers = /* @__PURE__ */ new Map();
+	context = {};
+	isInitialized = false;
+	providerMetrics = /* @__PURE__ */ new Map();
+	eventCache = new LRUCache(1e3);
+	rateLimiter = new RateLimiter({
+		maxCalls: 100,
+		windowMs: 1e3,
+		maxConcurrent: 10,
+		queueExcess: false
+	});
+	constructor(config, availableProviders) {
+		this.config = config;
+		this.availableProviders = availableProviders;
+	}
+	/**
+	* Initialize all configured providers
+	* Throws error if all providers fail to initialize
+	*/
+	async initialize() {
+		if (this.isInitialized) return;
+		const initPromises = [];
+		const initStartTime = process.hrtime.bigint();
+		for (const [providerName, providerConfig] of Object.entries(this.config.providers)) {
+			const providerFactory = this.availableProviders[providerName];
+			if (providerFactory) try {
+				const provider = providerFactory(providerConfig);
+				this.providers.set(providerName, provider);
+				initPromises.push((async () => {
+					const providerInitStart = typeof process.hrtime?.bigint === "function" ? process.hrtime.bigint() : BigInt(Date.now() * 1e6);
+					try {
+						const timeoutSignal = AbortSignal.timeout(1e4);
+						const initPromise = provider.initialize(providerConfig);
+						await Promise.race([initPromise, new Promise((_resolve, reject) => {
+							timeoutSignal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error(`Provider ${providerName} initialization timed out`)));
+						})]);
+						const now = typeof process.hrtime?.bigint === "function" ? process.hrtime.bigint() : BigInt(Date.now() * 1e6);
+						this.providerMetrics.set(providerName, {
+							initTime: now - providerInitStart,
+							callCount: 0,
+							errorCount: 0,
+							lastUsed: now
+						});
+					} catch (error) {
+						if (this.config.onError) this.config.onError(error, {
+							provider: providerName,
+							method: "initialize"
+						});
+						this.providers.delete(providerName);
+						throw error;
+					}
+				})());
+			} catch (error) {
+				if (this.config.onError) this.config.onError(error, {
+					provider: providerName,
+					method: "create"
+				});
+			}
+			else if (this.config.debug && this.config.onInfo) this.config.onInfo(`Provider ${providerName} not available in this environment`);
+		}
+		const results = await Promise.allSettled(initPromises);
+		const initEndTime = process.hrtime.bigint();
+		const successCount = results.filter((r) => r.status === "fulfilled").length;
+		const failureCount = results.filter((r) => r.status === "rejected").length;
+		if (successCount === 0 && initPromises.length > 0) throw new Error(`Analytics initialization failed: All ${initPromises.length} providers failed to initialize`);
+		this.isInitialized = true;
+		if (this.config.debug && this.config.onInfo) {
+			const initTimeMs = Number(initEndTime - initStartTime) / 1e6;
+			this.config.onInfo(`Analytics initialized in ${initTimeMs.toFixed(2)}ms with ${successCount} providers (${failureCount} failed): ${[...this.providers.keys()].join(", ")}`);
+		}
+	}
+	/**
+	* Set global analytics context
+	* FIX #13: Use spread operator instead of structuredClone for better performance
+	*/
+	setContext(context) {
+		this.context = {
+			...this.context,
+			...context
+		};
+		for (const [providerName, provider] of this.providers) if (provider.setContext) try {
+			provider.setContext({ ...this.context });
+			const metrics = this.providerMetrics.get(providerName);
+			if (metrics) metrics.lastUsed = process.hrtime.bigint();
+		} catch (error) {
+			if (this.config.onError) this.config.onError(error, {
+				provider: providerName,
+				method: "setContext",
+				context: Object.keys(context).join(", ")
+			});
+		}
+	}
+	/**
+	* Get current analytics context
+	* FIX #13: Use spread operator instead of structuredClone
+	*/
+	getContext() {
+		return { ...this.context };
+	}
+	async track(eventOrPayload, properties, options) {
+		if (typeof eventOrPayload === "object") {
+			const payload = eventOrPayload;
+			return this.track(payload.event, payload.properties, {
+				...options,
+				context: {
+					...this.context,
+					...payload.context
+				}
+			});
+		}
+		const event = eventOrPayload;
+		if (!this.isInitialized) {
+			if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error("Analytics not initialized"), {
+				provider: "analytics",
+				event,
+				method: "track"
+			});
+			return;
+		}
+		const eventValidation = validateEventName(event);
+		if (!eventValidation.valid) {
+			if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error(`Invalid event name: ${eventValidation.reason}`), {
+				provider: "analytics",
+				event,
+				method: "track"
+			});
+			return;
+		}
+		const sanitized = sanitizeProperties(properties ?? {}, {
+			stripPII: false,
+			stripHTML: true,
+			allowDangerousKeys: false
+		});
+		const targetProviders = this.getTargetProviders(options);
+		const enhancedProperties = {
+			...this.context,
+			...sanitized.data
+		};
+		const promises = [...targetProviders.entries()].map(async ([name, provider]) => {
+			if (!await this.rateLimiter.tryAcquire()) {
+				if (this.config.debug && this.config.onInfo) this.config.onInfo(`Rate limit exceeded for provider ${name}`);
+				if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error(`Rate limit exceeded for provider ${name}`), {
+					provider: name,
+					event,
+					method: "track"
+				});
+				return;
+			}
+			try {
+				await provider.track(event, enhancedProperties, this.context);
+				const metrics = this.providerMetrics.get(name);
+				if (metrics) {
+					metrics.callCount++;
+					metrics.lastUsed = process.hrtime.bigint();
+				}
+			} catch (error) {
+				const metrics = this.providerMetrics.get(name);
+				if (metrics) metrics.errorCount++;
+				if (this.config.onError) this.config.onError(error, {
+					provider: name,
+					event,
+					method: "track"
+				});
+			} finally {
+				this.rateLimiter.release();
+			}
+		});
+		await Promise.allSettled(promises);
+	}
+	async identify(userIdOrPayload, traits, options) {
+		if (typeof userIdOrPayload === "object") {
+			const payload = userIdOrPayload;
+			return this.identify(payload.userId, payload.traits, {
+				...options,
+				context: {
+					...this.context,
+					...payload.context
+				}
+			});
+		}
+		const userId = userIdOrPayload;
+		if (!this.isInitialized) {
+			if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error("Analytics not initialized"), {
+				provider: "analytics",
+				method: "identify",
+				userId
+			});
+			return;
+		}
+		const sanitized = sanitizeProperties(traits ?? {}, {
+			stripPII: false,
+			stripHTML: true,
+			allowDangerousKeys: false
+		});
+		this.setContext({
+			userId,
+			...sanitized.data
+		});
+		const targetProviders = this.getTargetProviders(options);
+		const enhancedTraits = { ...sanitized.data };
+		const promises = [...targetProviders.entries()].map(async ([name, provider]) => {
+			if (provider.identify) {
+				if (!await this.rateLimiter.tryAcquire()) {
+					if (this.config.debug && this.config.onInfo) this.config.onInfo(`Rate limit exceeded for provider ${name}`);
+					if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error(`Rate limit exceeded for provider ${name}`), {
+						provider: name,
+						userId,
+						method: "identify"
+					});
+					return;
+				}
+				try {
+					await provider.identify(userId, enhancedTraits, {
+						...options,
+						context: this.context
+					});
+					const metrics = this.providerMetrics.get(name);
+					if (metrics) {
+						metrics.callCount++;
+						metrics.lastUsed = process.hrtime.bigint();
+					}
+				} catch (error) {
+					const metrics = this.providerMetrics.get(name);
+					if (metrics) metrics.errorCount++;
+					if (this.config.onError) this.config.onError(error, {
+						provider: name,
+						method: "identify",
+						userId
+					});
+				} finally {
+					this.rateLimiter.release();
+				}
+			}
+		});
+		await Promise.allSettled(promises);
+	}
+	async page(nameOrPayload, properties, options) {
+		if (typeof nameOrPayload === "object") {
+			const payload = nameOrPayload;
+			return this.page(payload.name, payload.properties, {
+				...options,
+				context: {
+					...this.context,
+					...payload.context
+				}
+			});
+		}
+		const name = nameOrPayload;
+		if (!this.isInitialized) {
+			if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error("Analytics not initialized"), {
+				provider: "analytics",
+				name,
+				method: "page"
+			});
+			return;
+		}
+		const sanitized = sanitizeProperties(properties ?? {}, {
+			stripPII: false,
+			stripHTML: true,
+			allowDangerousKeys: false
+		});
+		const targetProviders = this.getTargetProviders(options);
+		const enhancedProperties = { ...sanitized.data };
+		const promises = [...targetProviders.entries()].map(async ([providerName, provider]) => {
+			if (provider.page) {
+				if (!await this.rateLimiter.tryAcquire()) {
+					if (this.config.debug && this.config.onInfo) this.config.onInfo(`Rate limit exceeded for provider ${providerName}`);
+					if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error(`Rate limit exceeded for provider ${providerName}`), {
+						provider: providerName,
+						name,
+						method: "page"
+					});
+					return;
+				}
+				try {
+					await provider.page(name ?? "", enhancedProperties, {
+						...options,
+						context: this.context
+					});
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) {
+						metrics.callCount++;
+						metrics.lastUsed = process.hrtime.bigint();
+					}
+				} catch (error) {
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) metrics.errorCount++;
+					if (this.config.onError) this.config.onError(error, {
+						provider: providerName,
+						name: name ?? "",
+						method: "page"
+					});
+				} finally {
+					this.rateLimiter.release();
+				}
+			}
+		});
+		await Promise.allSettled(promises);
+	}
+	async screen(nameOrPayload, properties, options) {
+		if (typeof nameOrPayload === "object") {
+			const payload = nameOrPayload;
+			return this.screen(payload.name, payload.properties, {
+				...options,
+				context: {
+					...this.context,
+					...payload.context
+				}
+			});
+		}
+		const name = nameOrPayload;
+		if (!this.isInitialized) {
+			if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error("Analytics not initialized"), {
+				provider: "analytics",
+				name,
+				method: "screen"
+			});
+			return;
+		}
+		const sanitized = sanitizeProperties(properties ?? {}, {
+			stripPII: false,
+			stripHTML: true,
+			allowDangerousKeys: false
+		});
+		const targetProviders = this.getTargetProviders(options);
+		const enhancedProperties = { ...sanitized.data };
+		const promises = [...targetProviders.entries()].map(async ([providerName, provider]) => {
+			if (provider.screen) {
+				if (!await this.rateLimiter.tryAcquire()) {
+					if (this.config.debug && this.config.onInfo) this.config.onInfo(`Rate limit exceeded for provider ${providerName}`);
+					if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error(`Rate limit exceeded for provider ${providerName}`), {
+						provider: providerName,
+						name,
+						method: "screen"
+					});
+					return;
+				}
+				try {
+					await provider.screen(name ?? "", enhancedProperties, {
+						...options,
+						context: this.context
+					});
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) {
+						metrics.callCount++;
+						metrics.lastUsed = process.hrtime.bigint();
+					}
+				} catch (error) {
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) metrics.errorCount++;
+					if (this.config.onError) this.config.onError(error, {
+						provider: providerName,
+						name: name ?? "",
+						method: "screen"
+					});
+				} finally {
+					this.rateLimiter.release();
+				}
+			}
+		});
+		await Promise.allSettled(promises);
+	}
+	async group(groupIdOrPayload, traits, options) {
+		if (typeof groupIdOrPayload === "object") {
+			const payload = groupIdOrPayload;
+			return this.group(payload.groupId, payload.traits, {
+				...options,
+				context: {
+					...this.context,
+					...payload.context
+				}
+			});
+		}
+		const groupId = groupIdOrPayload;
+		if (!this.isInitialized) {
+			if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error("Analytics not initialized"), {
+				provider: "analytics",
+				groupId,
+				method: "group"
+			});
+			return;
+		}
+		const sanitized = sanitizeProperties(traits ?? {}, {
+			stripPII: false,
+			stripHTML: true,
+			allowDangerousKeys: false
+		});
+		this.setContext({
+			organizationId: groupId,
+			...sanitized.data
+		});
+		const targetProviders = this.getTargetProviders(options);
+		const enhancedTraits = { ...sanitized.data };
+		const promises = [...targetProviders.entries()].map(async ([providerName, provider]) => {
+			if (provider.group) {
+				if (!await this.rateLimiter.tryAcquire()) {
+					if (this.config.debug && this.config.onInfo) this.config.onInfo(`Rate limit exceeded for provider ${providerName}`);
+					if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error(`Rate limit exceeded for provider ${providerName}`), {
+						provider: providerName,
+						groupId,
+						method: "group"
+					});
+					return;
+				}
+				try {
+					await provider.group(groupId, enhancedTraits, {
+						...options,
+						context: this.context
+					});
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) {
+						metrics.callCount++;
+						metrics.lastUsed = process.hrtime.bigint();
+					}
+				} catch (error) {
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) metrics.errorCount++;
+					if (this.config.onError) this.config.onError(error, {
+						provider: providerName,
+						groupId,
+						method: "group"
+					});
+				} finally {
+					this.rateLimiter.release();
+				}
+			}
+		});
+		await Promise.allSettled(promises);
+	}
+	async alias(userIdOrPayload, previousId, options) {
+		if (typeof userIdOrPayload === "object") {
+			const payload = userIdOrPayload;
+			return this.alias(payload.userId, payload.previousId, {
+				...options,
+				context: {
+					...this.context,
+					...payload.context
+				}
+			});
+		}
+		const userId = userIdOrPayload;
+		const prevId = previousId;
+		if (!this.isInitialized) {
+			if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error("Analytics not initialized"), {
+				provider: "analytics",
+				method: "alias",
+				previousId: prevId,
+				userId
+			});
+			return;
+		}
+		const promises = [...this.getTargetProviders(options).entries()].map(async ([providerName, provider]) => {
+			if (provider.alias) {
+				if (!await this.rateLimiter.tryAcquire()) {
+					if (this.config.debug && this.config.onInfo) this.config.onInfo(`Rate limit exceeded for provider ${providerName}`);
+					if (this.config.onError) this.config.onError(/* @__PURE__ */ new Error(`Rate limit exceeded for provider ${providerName}`), {
+						provider: providerName,
+						userId,
+						previousId,
+						method: "alias"
+					});
+					return;
+				}
+				try {
+					await provider.alias(userId, prevId, this.context);
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) {
+						metrics.callCount++;
+						metrics.lastUsed = process.hrtime.bigint();
+					}
+				} catch (error) {
+					const metrics = this.providerMetrics.get(providerName);
+					if (metrics) metrics.errorCount++;
+					if (this.config.onError) this.config.onError(error, {
+						provider: providerName,
+						method: "alias",
+						previousId: prevId,
+						userId
+					});
+				} finally {
+					this.rateLimiter.release();
+				}
+			}
+		});
+		await Promise.allSettled(promises);
+	}
+	/**
+	* Get list of active provider names
+	*/
+	getActiveProviders() {
+		return [...this.providers.keys()];
+	}
+	/**
+	* Get a specific provider instance
+	*/
+	getProvider(name) {
+		return this.providers.get(name);
+	}
+	/**
+	* Reset analytics context and identity
+	*/
+	reset() {
+		this.context = {};
+		this.eventCache.clear();
+	}
+	/**
+	* Shutdown all providers and cleanup resources
+	*/
+	async shutdown() {
+		const shutdownPromises = [...this.providers.entries()].map(async ([name, provider]) => {
+			try {
+				if (typeof provider.destroy === "function") await provider.destroy();
+			} catch (error) {
+				if (this.config.onError) this.config.onError(error, {
+					provider: name,
+					method: "shutdown"
+				});
+			}
+		});
+		await Promise.allSettled(shutdownPromises);
+		this.providers.clear();
+		this.isInitialized = false;
+	}
+	/**
+	* Process any emitter payload with Node 22+ optimizations
+	* FIX #12: Use LRU cache for event deduplication (prevents memory leaks)
+	*/
+	async emit(payload, options) {
+		const emitStartTime = process.hrtime.bigint();
+		const createCacheKey = (p) => {
+			const sorted = (obj) => {
+				if (obj === null || typeof obj !== "object" || obj instanceof Array) return obj;
+				const sortedObj = {};
+				for (const key of Object.keys(obj).sort()) sortedObj[key] = sorted(obj[key]);
+				return sortedObj;
+			};
+			return JSON.stringify(sorted(p));
+		};
+		const cacheKey = createCacheKey(payload);
+		if (this.eventCache.has(cacheKey)) {
+			if (this.eventCache.get(cacheKey)?.processed) {
+				if (this.config.debug && this.config.onInfo) this.config.onInfo("Skipping duplicate event processing");
+				return;
+			}
+		}
+		this.eventCache.set(cacheKey, {
+			timestamp: emitStartTime,
+			processed: true
+		});
+		try {
+			if (options?.timeout) {
+				const timeoutSignal = AbortSignal.timeout(options.timeout);
+				await Promise.race([this.processPayloadByType(payload), new Promise((_resolve, reject) => {
+					timeoutSignal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error(`Event processing timed out after ${options.timeout}ms`)));
+				})]);
+			} else await this.processPayloadByType(payload);
+			if (this.config.debug && this.config.onInfo) {
+				const processingTime = Number(process.hrtime.bigint() - emitStartTime) / 1e6;
+				this.config.onInfo(`Event processed in ${processingTime.toFixed(2)}ms`);
+			}
+		} catch (error) {
+			this.eventCache.set(cacheKey, {
+				timestamp: emitStartTime,
+				processed: false
+			});
+			throw error;
+		}
+	}
+	/**
+	* Route payload to appropriate method based on type
+	*/
+	async processPayloadByType(payload) {
+		switch (payload.type) {
+			case "track": return this.track(payload);
+			case "identify": return this.identify(payload);
+			case "page": return this.page(payload);
+			case "screen": return this.screen(payload);
+			case "group": return this.group(payload);
+			case "alias": return this.alias(payload);
+		}
+	}
+	/**
+	* Process an emitter payload (legacy method - use emit() instead)
+	* @deprecated Use emit() for better type safety
+	*/
+	async processEmitterPayload(payload) {
+		return this.emit(payload);
+	}
+	/**
+	* Batch emit multiple payloads with Node 22+ optimizations
+	* FIX #14: Process chunks concurrently instead of sequentially
+	* FIX #13: Use spread operator instead of structuredClone
+	*/
+	async emitBatch(payloads, options) {
+		const batchStartTime = process.hrtime.bigint();
+		const concurrency = options?.concurrency ?? 10;
+		if (payloads.length === 0) return;
+		const clonedPayloads = payloads.map((p) => structuredClone(p));
+		const chunks = [];
+		for (let i = 0; i < clonedPayloads.length; i += concurrency) chunks.push(clonedPayloads.slice(i, i + concurrency));
+		const processChunk = async (chunk) => {
+			const chunkPromises = chunk.map((payload) => this.emit(payload, options?.timeout !== void 0 ? { timeout: options.timeout } : void 0));
+			if (options?.failFast) await Promise.all(chunkPromises);
+			else await Promise.allSettled(chunkPromises);
+		};
+		const chunkPromises = chunks.map((chunk) => processChunk(chunk));
+		await Promise.all(chunkPromises);
+		if (this.config.debug && this.config.onInfo) {
+			const batchTime = Number(process.hrtime.bigint() - batchStartTime) / 1e6;
+			this.config.onInfo(`Batch of ${payloads.length} events processed in ${batchTime.toFixed(2)}ms (concurrency: ${concurrency})`);
+		}
+	}
+	/**
+	* Create a bound emitter function for convenience
+	*/
+	createEmitter() {
+		return this.emit.bind(this);
+	}
+	/**
+	* Track an ecommerce event specification
+	* @deprecated Use emit(ecommerce.EVENT_NAME(...)) instead
+	*/
+	async trackEcommerce(eventSpec) {
+		return this.track(eventSpec.name, eventSpec.properties);
+	}
+	/**
+	* Get target providers based on tracking options
+	*/
+	getTargetProviders(options) {
+		let targetProviders = new Map(this.providers);
+		if (options) {
+			if (options.providers && Object.hasOwn(options, "providers")) for (const [name, config] of Object.entries(options.providers)) {
+				const factory = this.availableProviders[name];
+				if (factory) try {
+					const provider = factory(config);
+					targetProviders.set(name, provider);
+					this.providerMetrics.set(name, {
+						initTime: process.hrtime.bigint(),
+						callCount: 0,
+						errorCount: 0,
+						lastUsed: process.hrtime.bigint()
+					});
+				} catch (error) {
+					if (this.config.onError) this.config.onError(error, {
+						provider: name,
+						method: "runtime-create"
+					});
+				}
+			}
+			if (options.only && Object.hasOwn(options, "only")) {
+				const onlyProviders = /* @__PURE__ */ new Map();
+				for (const name of options.only) if (targetProviders.has(name)) onlyProviders.set(name, targetProviders.get(name));
+				targetProviders = onlyProviders;
+			}
+			if (options.exclude && Object.hasOwn(options, "exclude")) for (const name of options.exclude) targetProviders.delete(name);
+		}
+		return targetProviders;
+	}
+	/**
+	* Get analytics performance metrics using Node 22+ features
+	*/
+	getAnalyticsMetrics() {
+		const now = process.hrtime.bigint();
+		const providers = {};
+		for (const [providerName, metrics] of this.providerMetrics) providers[providerName] = {
+			initTimeMs: Number(metrics.initTime) / 1e6,
+			callCount: metrics.callCount,
+			errorCount: metrics.errorCount,
+			lastUsedMs: Number(now - metrics.lastUsed) / 1e6,
+			successRate: metrics.callCount > 0 ? 1 - metrics.errorCount / metrics.callCount : 1
+		};
+		return {
+			providers,
+			events: {
+				totalProcessed: this.eventCache.size,
+				cacheSize: this.eventCache.size,
+				memoryUsage: process.memoryUsage()
+			}
+		};
+	}
+	/**
+	* Health check for analytics system using Node 22+ timing
+	* FIX #16: Send actual test events instead of just setContext
+	*/
+	async healthCheck(timeout = 5e3) {
+		const checkStartTime = process.hrtime.bigint();
+		const providerHealth = {};
+		const timeoutSignal = AbortSignal.timeout(timeout);
+		try {
+			const healthPromises = [...this.providers.entries()].map(async ([name, provider]) => {
+				try {
+					await Promise.race([provider.track("__health_check__", {
+						timestamp: Date.now(),
+						provider: name
+					}), new Promise((_resolve, reject) => {
+						timeoutSignal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("Health check timeout")));
+					})]);
+					providerHealth[name] = true;
+				} catch {
+					providerHealth[name] = false;
+				}
+			});
+			await Promise.allSettled(healthPromises);
+			const checkEndTime = process.hrtime.bigint();
+			const totalCheckTime = Number(checkEndTime - checkStartTime) / 1e6;
+			return {
+				healthy: Object.values(providerHealth).filter(Boolean).length > 0 && this.isInitialized,
+				providers: providerHealth,
+				metrics: this.getAnalyticsMetrics(),
+				totalCheckTime
+			};
+		} catch {
+			return {
+				healthy: false,
+				providers: providerHealth,
+				metrics: this.getAnalyticsMetrics(),
+				totalCheckTime: Number(process.hrtime.bigint() - checkStartTime) / 1e6
+			};
+		}
+	}
+};
+/**
+* Factory function to create analytics manager
+*/
+function createAnalyticsManager(config, availableProviders) {
+	return new AnalyticsManager(config, availableProviders);
+}
+
+//#endregion
+//#region src/shared/emitters/helpers.ts
+/**
+* @fileoverview Helper Functions for Analytics Emitters
+*
+* These utilities make it easier to use the emitter-first approach for analytics.
+* Provides builders, batch processing, session management, and convenience
+* functions for common tracking patterns.
+*
+* **Builders**:
+* - `ContextBuilder`: Build consistent context across events
+* - `PayloadBuilder`: Chain emitter creation with shared options
+* - `EventBatch`: Batch related events with shared context
+*
+* **Session Management**:
+* - `createUserSession()`: Create a user session tracking flow
+* - `createAnonymousSession()`: Create an anonymous user tracking flow
+*
+* **Convenience Functions**:
+* - `withMetadata()`: Add consistent metadata to events
+* - `withUTM()`: Add UTM parameters to events
+* - Type guards: `isTrackPayload()`, `isIdentifyPayload()`, etc.
+*
+* @module @od-oneapp/analytics/shared/emitters/helpers
+*/
+/**
+* Builder for creating consistent context across analytics events.
+*
+* @remarks
+* Use this builder to create a reusable context object that can be applied
+* to multiple events. This ensures consistency and reduces repetition.
+*
+* @example
+* ```typescript
+* const context = new ContextBuilder()
+*   .setUser('user-123', { plan: 'pro' })
+*   .setOrganization('org-456')
+*   .setPage({ path: '/dashboard', title: 'Dashboard' })
+*   .build();
+*
+* await analytics.emit(track('Button Clicked', {}, { context }));
+* ```
+*/
+var ContextBuilder = class {
+	context = {};
+	constructor(initialContext) {
+		if (initialContext) this.context = { ...initialContext };
+	}
+	setUser(_userId, traits) {
+		this.context.traits = {
+			...this.context.traits,
+			...traits
+		};
+		return this;
+	}
+	setOrganization(groupId) {
+		this.context.groupId = groupId;
+		return this;
+	}
+	setPage(pageInfo) {
+		this.context.page = {
+			...this.context.page,
+			...pageInfo
+		};
+		return this;
+	}
+	setCampaign(utmParams) {
+		this.context.campaign = {
+			...this.context.campaign,
+			...utmParams
+		};
+		return this;
+	}
+	setDevice(deviceInfo) {
+		this.context.device = {
+			...this.context.device,
+			...deviceInfo
+		};
+		return this;
+	}
+	build() {
+		return { ...this.context };
+	}
+};
+/**
+* Builder for chaining emitter creation with shared options.
+*
+* @remarks
+* Use this builder to create multiple events with shared options like
+* timestamp, anonymousId, or integrations. This is useful when tracking
+* multiple related events in a single flow.
+*
+* @example
+* ```typescript
+* const builder = new PayloadBuilder(context)
+*   .withTimestamp(new Date())
+*   .withAnonymousId('anon-123');
+*
+* await analytics.emit(builder.track('Event 1', {}));
+* await analytics.emit(builder.track('Event 2', {}));
+* ```
+*/
+var PayloadBuilder = class {
+	options = {};
+	constructor(context) {
+		if (context) this.options.context = context;
+	}
+	withTimestamp(timestamp) {
+		this.options.timestamp = timestamp;
+		return this;
+	}
+	withAnonymousId(anonymousId) {
+		this.options.anonymousId = anonymousId;
+		return this;
+	}
+	withIntegrations(integrations) {
+		this.options.integrations = integrations;
+		return this;
+	}
+	track(event, properties) {
+		return track(event, properties, this.options);
+	}
+	identify(userId, traits) {
+		return identify(userId, traits, this.options);
+	}
+	page(name, properties) {
+		return page(void 0, name, properties, this.options);
+	}
+	group(groupId, traits) {
+		return group(groupId, traits, this.options);
+	}
+	alias(userId, previousId) {
+		return alias(userId, previousId, this.options);
+	}
+};
+/**
+* Batch processor for related events with shared context.
+*
+* @remarks
+* Use this class to collect multiple events and emit them together with
+* a shared context. This is useful for tracking user flows or multi-step
+* processes where events should be grouped together.
+*
+* @example
+* ```typescript
+* const batch = new EventBatch(context)
+*   .addTrack('Step 1 Completed', { step: 1 })
+*   .addTrack('Step 2 Completed', { step: 2 })
+*   .addTrack('Flow Completed', { totalSteps: 2 });
+*
+* for (const event of batch.getEvents()) {
+*   await analytics.emit(event);
+* }
+* ```
+*/
+var EventBatch = class {
+	events = [];
+	sharedContext;
+	constructor(context) {
+		this.sharedContext = context ?? {};
+	}
+	add(payload) {
+		const enrichedPayload = {
+			...payload,
+			context: {
+				...this.sharedContext,
+				...payload.context
+			}
+		};
+		this.events.push(enrichedPayload);
+		return this;
+	}
+	addTrack(event, properties) {
+		return this.add(track(event, properties, { context: this.sharedContext }));
+	}
+	addIdentify(userId, traits) {
+		return this.add(identify(userId, traits, { context: this.sharedContext }));
+	}
+	addPage(name, properties) {
+		return this.add(page(void 0, name, properties, { context: this.sharedContext }));
+	}
+	addGroup(groupId, traits) {
+		return this.add(group(groupId, traits, { context: this.sharedContext }));
+	}
+	getEvents() {
+		return [...this.events];
+	}
+	clear() {
+		this.events = [];
+	}
+};
+/**
+* Creates a user session tracking flow with pre-configured context.
+*
+* @remarks
+* This helper creates a session object with methods for tracking events
+* within a specific user session. All events will include the sessionId
+* and user context automatically.
+*
+* @param userId - Unique identifier for the user
+* @param sessionId - Unique identifier for the session
+* @returns Session object with `identify`, `track`, `page`, and `group` methods
+*
+* @example
+* ```typescript
+* const session = createUserSession('user-123', 'session-456');
+* await analytics.emit(session.track('Button Clicked', { button: 'signup' }));
+* await analytics.emit(session.page('Dashboard'));
+* ```
+*/
+function createUserSession(userId, sessionId) {
+	const context = new ContextBuilder().setUser(userId).build();
+	return {
+		identify: (traits) => identify(userId, {
+			...traits,
+			sessionId
+		}, { context }),
+		track: (event, properties) => track(event, {
+			...properties,
+			sessionId
+		}, { context }),
+		page: (name, properties) => page(void 0, name, {
+			...properties,
+			sessionId
+		}, { context }),
+		group: (groupId, traits) => group(groupId, {
+			...traits,
+			sessionId
+		}, { context })
+	};
+}
+/**
+* Creates an anonymous user tracking flow.
+*
+* @remarks
+* This helper creates a session object for tracking anonymous users before
+* they are identified. When the user signs up or logs in, use the `alias`
+* method to link their anonymous activity to their user ID.
+*
+* @param anonymousId - Unique identifier for the anonymous user
+* @returns Session object with `track`, `page`, `identify`, and `alias` methods
+*
+* @example
+* ```typescript
+* const anonymousSession = createAnonymousSession('anon-123');
+* await analytics.emit(anonymousSession.track('Page Viewed', { page: 'home' }));
+*
+* // Later, when user signs up
+* await analytics.emit(anonymousSession.alias('user-123'));
+* await analytics.emit(anonymousSession.identify('user-123', { email: 'user@example.com' }));
+* ```
+*/
+function createAnonymousSession(anonymousId) {
+	const options = { anonymousId };
+	return {
+		track: (event, properties) => track(event, properties, options),
+		page: (name, properties) => page(void 0, name, properties, options),
+		identify: (userId, traits) => identify(userId, traits, options),
+		alias: (userId) => alias(userId, anonymousId, options)
+	};
+}
+/**
+* Type guard to check if a payload is a track event.
+*
+* @param payload - The payload to check
+* @returns True if the payload is a track event
+*/
+const isTrackPayload = (payload) => payload.type === "track";
+/**
+* Type guard to check if a payload is an identify event.
+*
+* @param payload - The payload to check
+* @returns True if the payload is an identify event
+*/
+const isIdentifyPayload = (payload) => payload.type === "identify";
+/**
+* Type guard to check if a payload is a page event.
+*
+* @param payload - The payload to check
+* @returns True if the payload is a page event
+*/
+const isPagePayload = (payload) => payload.type === "page";
+/**
+* Type guard to check if a payload is a group event.
+*
+* @param payload - The payload to check
+* @returns True if the payload is a group event
+*/
+const isGroupPayload = (payload) => payload.type === "group";
+/**
+* Type guard to check if a payload is an alias event.
+*
+* @param payload - The payload to check
+* @returns True if the payload is an alias event
+*/
+const isAliasPayload = (payload) => payload.type === "alias";
+/**
+* Adds consistent metadata to an analytics event payload.
+*
+* @remarks
+* This helper enriches an event payload with metadata that will be included
+* in the event's context.app object. Useful for tracking version, source,
+* or other application-level metadata.
+*
+* @param payload - The event payload to enrich
+* @param metadata - Metadata to add (version, source, or custom properties)
+* @returns The enriched payload with metadata in context.app
+*
+* @example
+* ```typescript
+* const event = track('Button Clicked', { button: 'signup' });
+* const enriched = withMetadata(event, { version: '1.0.0', source: 'webapp' });
+* await analytics.emit(enriched);
+* ```
+*/
+function withMetadata(payload, metadata) {
+	return {
+		...payload,
+		context: {
+			...payload.context,
+			app: {
+				...payload.context?.app,
+				...metadata
+			}
+		}
+	};
+}
+/**
+* Adds UTM parameters to an analytics event payload.
+*
+* @remarks
+* This helper enriches an event payload with UTM campaign parameters that
+* will be included in the event's context.campaign object. Useful for
+* tracking marketing campaign attribution.
+*
+* @param payload - The event payload to enrich
+* @param utm - UTM parameters (source, medium, campaign, term, content)
+* @returns The enriched payload with UTM parameters in context.campaign
+*
+* @example
+* ```typescript
+* const event = track('Signup Started', {});
+* const enriched = withUTM(event, {
+*   source: 'google',
+*   medium: 'cpc',
+*   campaign: 'summer-sale'
+* });
+* await analytics.emit(enriched);
+* ```
+*/
+function withUTM(payload, utm) {
+	return {
+		...payload,
+		context: {
+			...payload.context,
+			campaign: {
+				...payload.context?.campaign,
+				...utm
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/utils/posthog-bootstrap.ts
+/**
+* Generate a unique distinct ID (compatible with PostHog format)
+*/
+function generateDistinctId() {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 15)}`;
+}
+/**
+* Parse PostHog cookie to extract distinct ID
+*/
+function parsePostHogCookie(cookieValue, _projectApiKey) {
+	try {
+		const parsed = JSON.parse(cookieValue);
+		if (parsed && typeof parsed.distinct_id === "string") return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Get PostHog cookie name for a project
+*/
+function getPostHogCookieName(projectApiKey) {
+	return `ph_${projectApiKey}_posthog`;
+}
+/**
+* Extract distinct ID from cookies (Next.js compatible)
+*/
+function getDistinctIdFromCookies(cookies, projectApiKey) {
+	try {
+		const cookieName = getPostHogCookieName(projectApiKey);
+		if (cookies && typeof cookies.get === "function") {
+			const cookie = cookies.get(cookieName);
+			if (cookie?.value) return parsePostHogCookie(cookie.value, projectApiKey)?.distinct_id ?? null;
+		}
+		if (typeof cookies === "string") {
+			const cookieMatch = cookies.match(new RegExp(`${cookieName}=([^;]+)`));
+			if (cookieMatch?.[1]) return parsePostHogCookie(decodeURIComponent(cookieMatch[1]), projectApiKey)?.distinct_id ?? null;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Create bootstrap data for PostHog client initialization
+*/
+function createBootstrapData(distinctId) {
+	return { distinctID: distinctId };
+}
+/**
+* Create minimal bootstrap data when full data is unavailable
+*/
+function createMinimalBootstrapData(distinctId) {
+	return { distinctID: distinctId ?? generateDistinctId() };
+}
+
+//#endregion
+export { AnalyticsManager as _, ContextBuilder as a, validateEventName as b, createAnonymousSession as c, isGroupPayload as d, isIdentifyPayload as f, withUTM as g, withMetadata as h, getDistinctIdFromCookies as i, createUserSession as l, isTrackPayload as m, createMinimalBootstrapData as n, EventBatch as o, isPagePayload as p, generateDistinctId as r, PayloadBuilder as s, createBootstrapData as t, isAliasPayload as u, createAnalyticsManager as v, sanitizeProperties as y };
+//# sourceMappingURL=posthog-bootstrap-CYfIy_WS.mjs.map